Package evaluation to load MultiAssayExperiments on Julia 1.14.0-DEV.2309 (6e1a27e459*) started at 2026-06-06T11:40:53.814 ################################################################################ # Set-up # Set-up completed after 0.11s ################################################################################ # Installation # Installing MultiAssayExperiments... Resolving package versions... Installed DataAPI ───────────────────── v1.16.0 Installed IteratorInterfaceExtensions ─ v1.0.0 Installed OrderedCollections ────────── v1.8.2 Installed Statistics ────────────────── v1.11.1 Installed DataValueInterfaces ───────── v1.0.0 Installed InvertedIndices ───────────── v1.3.1 Installed SentinelArrays ────────────── v1.4.10 Installed Compat ────────────────────── v4.18.1 Installed InlineStrings ─────────────── v1.4.5 Installed SummarizedExperiments ─────── v0.2.0 Installed DataStructures ────────────── v0.18.22 Installed PrecompileTools ───────────── v1.3.4 Installed Reexport ──────────────────── v1.2.2 Installed Missings ──────────────────── v1.2.0 Installed PooledArrays ──────────────── v1.4.3 Installed Tables ────────────────────── v1.12.1 Installed TableTraits ───────────────── v1.0.1 Installed LaTeXStrings ──────────────── v1.4.0 Installed Crayons ───────────────────── v4.1.1 Installed SortingAlgorithms ─────────── v1.2.2 Installed StringManipulation ────────── v0.4.4 Installed Preferences ───────────────── v1.5.2 Installed MultiAssayExperiments ─────── v0.2.0 Installed DataFrames ────────────────── v1.8.2 Installed PrettyTables ──────────────── v3.3.2 Updating `~/.julia/environments/v1.14/Project.toml` [c9137f73] + MultiAssayExperiments v0.2.0 Updating `~/.julia/environments/v1.14/Manifest.toml` [34da2185] + Compat v4.18.1 [a8cc5b0e] + Crayons v4.1.1 [9a962f9c] + DataAPI v1.16.0 [a93c6f00] + DataFrames v1.8.2 ⌅ [864edb3b] + DataStructures v0.18.22 [e2d170a0] + DataValueInterfaces v1.0.0 [842dd82b] + InlineStrings v1.4.5 [41ab1584] + InvertedIndices v1.3.1 [82899510] + IteratorInterfaceExtensions v1.0.0 [b964fa9f] + LaTeXStrings v1.4.0 [e1d29d7a] + Missings v1.2.0 [c9137f73] + MultiAssayExperiments v0.2.0 ⌅ [bac558e1] + OrderedCollections v1.8.2 [2dfb63ee] + PooledArrays v1.4.3 [aea7be01] + PrecompileTools v1.3.4 [21216c6a] + Preferences v1.5.2 [08abe8d2] + PrettyTables v3.3.2 [189a3867] + Reexport v1.2.2 [91c51154] + SentinelArrays v1.4.10 [a2af1166] + SortingAlgorithms v1.2.2 [10745b16] + Statistics v1.11.1 [892a3eda] + StringManipulation v0.4.4 [b04b66ec] + SummarizedExperiments v0.2.0 [3783bdb8] + TableTraits v1.0.1 [bd369af6] + Tables v1.12.1 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [7b1f6079] + FileWatching v1.11.0 [9fa8497b] + Future v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.13.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.14.0 [d6f4376e] + Markdown v1.11.0 [de0858da] + Printf v1.11.0 [3fa0cd96] + REPL v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.13.0 [6462fe0b] + Sockets v1.11.0 [f489334b] + StyledStrings v1.13.0 [fa267f1f] + TOML v1.0.3 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.2+0 [4536629a] + OpenBLAS_jll v0.3.33+0 [8e850b90] + libblastrampoline_jll v5.15.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m` Installation completed after 9.59s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Project No packages added to or removed from `~/.julia/environments/pkgeval/Project.toml` Manifest No packages added to or removed from `~/.julia/environments/pkgeval/Manifest.toml` Precompiling package dependencies... Precompiling project... 0.5 s ✓ DataValueInterfaces 324.6 s ✓ InlineStrings 0.6 s ✓ Reexport 151.4 s ✓ OrderedCollections 1.1 s ✓ DataAPI 1.1 s ✓ Statistics 58.0 s ✓ InvertedIndices 0.5 s ✓ IteratorInterfaceExtensions 42.8 s ✓ LaTeXStrings 2.5 s ✓ Crayons 162.1 s ✓ SentinelArrays 2.8 s ✓ Preferences 1.5 s ✓ Compat 56.6 s ✓ Missings 23.8 s ✓ PooledArrays 0.5 s ✓ TableTraits 3.2 s ✓ PrecompileTools 0.7 s ✓ Compat → CompatLinearAlgebraExt 154.2 s ✓ Tables 78.5 s ✓ StringManipulation 273.5 s ✓ DataStructures 210.7 s ✓ PrettyTables 39.6 s ✓ SortingAlgorithms 339.0 s ✓ DataFrames ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 =# Core.@doc "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" mutable struct SummarizedExperiment │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:42 =# │ assays::OrderedDict{String, AbstractArray} │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:43 =# │ rowdata::DataFrame │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:44 =# │ coldata::DataFrame │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:45 =# │ metadata::Dict{String, Any} │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =# @doc " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" function SummarizedExperiment() │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:66 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:67 =# │ dummy = DataFrame(name = String[]) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:68 =# │ new(OrderedDict{String, AbstractArray}(), dummy, deepcopy(dummy), Dict{String, Any}()) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =# @doc " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" function SummarizedExperiment(assays::OrderedDict{String, AbstractArray}) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:106 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:107 =# │ if length(assays) < 1 │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:108 =# │ throw(ErrorException("expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied")) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:111 =# │ refdims = size((first(assays)).second) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:112 =# │ if length(refdims) < 2 │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:113 =# │ throw(DimensionMismatch("'assays' should contain arrays with 2 or more dimensions")) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:116 =# │ first_name = (first(assays)).first │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:117 =# │ for (key, val) = assays │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:118 =# │ if !(check_assay_dimensions(size(val), refdims)) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:119 =# │ throw(DimensionMismatch("'assays[" * repr(key) * "]' and 'assays[" * repr(first_name) * "]' should have the same extents for the first 2 dimensions")) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:122 =# │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:124 =# │ rowdata = DataFrame(name = Vector{Nothing}(undef, refdims[1])) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:125 =# │ coldata = DataFrame(name = Vector{Nothing}(undef, refdims[2])) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:126 =# │ new(assays, rowdata, coldata, Dict{String, Any}()) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =# @doc " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" function SummarizedExperiment(assays::OrderedDict{String, AbstractArray}, rowdata::DataFrame, coldata::DataFrame, metadata::Dict{String, Any} = Dict{String, Any}()) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:170 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:177 =# │ refdims = ((size(rowdata))[1], (size(coldata))[1]) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:179 =# │ for (key, val) = assays │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:180 =# │ if !(check_assay_dimensions(size(val), refdims)) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:181 =# │ throw(DimensionMismatch("dimensions of 'assays[" * repr(key) * "]' are not consistent with 'rowdata' or 'coldata'")) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:183 =# │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:185 =# │ check_dataframe_in_constructor(rowdata, "rowdata") │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:186 =# │ check_dataframe_in_constructor(coldata, "coldata") │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:187 =# │ new(assays, rowdata, coldata, metadata) │ end │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 =#) :: Value │ │ "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" :: Value │ │ [struct] │ │ true :: Value │ │ SummarizedExperiment :: Identifier │ │ [block] │ │ [::] │ │ assays :: Identifier │ │ [curly] │ │ OrderedDict :: Identifier │ │ String :: Identifier │ │ AbstractArray :: Identifier │ │ [::] │ │ rowdata :: Identifier │ │ DataFrame :: Identifier │ │ [::] │ │ coldata :: Identifier │ │ DataFrame :: Identifier │ │ [::] │ │ metadata :: Identifier │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =#) :: Value │ │ " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ │ [block] │ │ [=] │ │ dummy :: Identifier │ │ [call] │ │ DataFrame :: Identifier │ │ [kw] │ │ name :: Identifier │ │ [ref] │ │ String :: Identifier │ │ [call] │ │ new :: Identifier │ │ [call] │ │ [curly] │ │ OrderedDict :: Identifier │ │ String :: Identifier │ │ AbstractArray :: Identifier │ │ dummy :: Identifier │ │ [call] │ │ deepcopy :: Identifier │ │ dummy :: Identifier │ │ [call] │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =#) :: Value │ │ " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ │ [::] │ │ assays :: Identifier │ │ [curly] │ │ OrderedDict :: Identifier │ │ String :: Identifier │ │ AbstractArray :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ < :: Identifier │ │ [call] │ │ length :: Identifier │ │ assays :: Identifier │ │ 1 :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ ErrorException :: Identifier │ │ "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied" :: Value │ │ [=] │ │ refdims :: Identifier │ │ [call] │ │ size :: Identifier │ │ [.] │ │ [call] │ │ first :: Identifier │ │ assays :: Identifier │ │ [inert] │ │ second :: Identifier │ │ [if] │ │ [call] │ │ < :: Identifier │ │ [call] │ │ length :: Identifier │ │ refdims :: Identifier │ │ 2 :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ DimensionMismatch :: Identifier │ │ "'assays' should contain arrays with 2 or more dimensions" :: Value │ │ [=] │ │ first_name :: Identifier │ │ [.] │ │ [call] │ │ first :: Identifier │ │ assays :: Identifier │ │ [inert] │ │ first :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ key :: Identifier │ │ val :: Identifier │ │ assays :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ check_assay_dimensions :: Identifier │ │ [call] │ │ size :: Identifier │ │ val :: Identifier │ │ refdims :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ DimensionMismatch :: Identifier │ │ [call] │ │ * :: Identifier │ │ "'assays[" :: Value │ │ [call] │ │ repr :: Identifier │ │ key :: Identifier │ │ "]' and 'assays[" :: Value │ │ [call] │ │ repr :: Identifier │ │ first_name :: Identifier │ │ "]' should have the same extents for the first 2 dimensions" :: Value │ │ [=] │ │ rowdata :: Identifier │ │ [call] │ │ DataFrame :: Identifier │ │ [kw] │ │ name :: Identifier │ │ [call] │ │ [curly] │ │ Vector :: Identifier │ │ Nothing :: Identifier │ │ undef :: Identifier │ │ [ref] │ │ refdims :: Identifier │ │ 1 :: Value │ │ [=] │ │ coldata :: Identifier │ │ [call] │ │ DataFrame :: Identifier │ │ [kw] │ │ name :: Identifier │ │ [call] │ │ [curly] │ │ Vector :: Identifier │ │ Nothing :: Identifier │ │ undef :: Identifier │ │ [ref] │ │ refdims :: Identifier │ │ 2 :: Value │ │ [call] │ │ new :: Identifier │ │ assays :: Identifier │ │ rowdata :: Identifier │ │ coldata :: Identifier │ │ [call] │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =#) :: Value │ │ " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" :: Value │ │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ │ [::] │ │ assays :: Identifier │ │ [curly] │ │ OrderedDict :: Identifier │ │ String :: Identifier │ │ AbstractArray :: Identifier │ │ [::] │ │ rowdata :: Identifier │ │ DataFrame :: Identifier │ │ [::] │ │ coldata :: Identifier │ │ DataFrame :: Identifier │ │ [kw] │ │ [::] │ │ metadata :: Identifier │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [call] │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [block] │ │ [=] │ │ refdims :: Identifier │ │ [tuple] │ │ [ref] │ │ [call] │ │ size :: Identifier │ │ rowdata :: Identifier │ │ 1 :: Value │ │ [ref] │ │ [call] │ │ size :: Identifier │ │ coldata :: Identifier │ │ 1 :: Value │ │ [for] │ │ [=] │ │ [tuple] │ │ key :: Identifier │ │ val :: Identifier │ │ assays :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ check_assay_dimensions :: Identifier │ │ [call] │ │ size :: Identifier │ │ val :: Identifier │ │ refdims :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ DimensionMismatch :: Identifier │ │ [call] │ │ * :: Identifier │ │ "dimensions of 'assays[" :: Value │ │ [call] │ │ repr :: Identifier │ │ key :: Identifier │ │ "]' are not consistent with 'rowdata' or 'coldata'" :: Value │ │ [call] │ │ check_dataframe_in_constructor :: Identifier │ │ rowdata :: Identifier │ │ "rowdata" :: Value │ │ [call] │ │ check_dataframe_in_constructor :: Identifier │ │ coldata :: Identifier │ │ "coldata" :: Value │ │ [call] │ │ new :: Identifier │ │ assays :: Identifier │ │ rowdata :: Identifier │ │ coldata :: Identifier │ │ metadata :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [struct] │ │ true :: Value │ macro_source=273 │ SummarizedExperiment :: Identifier │ scope_layer=1 │ [block] │ │ [::] │ │ assays :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ [::] │ │ rowdata :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [::] │ │ coldata :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [::] │ │ metadata :: Identifier │ scope_layer=1 │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #1#val :: Identifier │ scope_layer=1 │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ dummy :: Identifier │ scope_layer=1 │ [call] │ │ DataFrame :: Identifier │ scope_layer=1 │ [kw] │ │ name :: Identifier │ scope_layer=1 │ [ref] │ │ String :: Identifier │ scope_layer=1 │ [call] │ │ new :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ dummy :: Identifier │ scope_layer=1 │ [call] │ │ deepcopy :: Identifier │ scope_layer=1 │ dummy :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [inert] │ │ SummarizedExperiment :: Identifier │ │ [call] │ macro_source=273 │ Base.Docs.docstr :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Core.svec :: Value │ macro_source=273 │ " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Dict{Symbol, Any} :: Value │ macro_source=273 │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ :linenumber => 47 :: Value │ macro_source=273 │ :module => SummarizedExperiments :: Value │ macro_source=273 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ #1#val :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #2#val :: Identifier │ scope_layer=1 │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ [::] │ │ assays :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ < :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=273 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ ErrorException :: Identifier │ scope_layer=1 │ "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied" :: Value │ macro_source=273 │ [=] │ │ refdims :: Identifier │ scope_layer=1 │ [call] │ │ size :: Identifier │ scope_layer=1 │ [.] │ │ [call] │ │ first :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ [inert] │ │ second :: Identifier │ │ [if] │ │ [call] │ │ < :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ refdims :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=273 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ DimensionMismatch :: Identifier │ scope_layer=1 │ "'assays' should contain arrays with 2 or more dimensions" :: Value │ macro_source=273 │ [=] │ │ first_name :: Identifier │ scope_layer=1 │ [.] │ │ [call] │ │ first :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ [inert] │ │ first :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ key :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ check_assay_dimensions :: Identifier │ scope_layer=1 │ [call] │ │ size :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=1 │ refdims :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ DimensionMismatch :: Identifier │ scope_layer=1 │ [call] │ │ * :: Identifier │ scope_layer=1 │ "'assays[" :: Value │ macro_source=273 │ [call] │ │ repr :: Identifier │ scope_layer=1 │ key :: Identifier │ scope_layer=1 │ "]' and 'assays[" :: Value │ macro_source=273 │ [call] │ │ repr :: Identifier │ scope_layer=1 │ first_name :: Identifier │ scope_layer=1 │ "]' should have the same extents for the first 2 dimensions" :: Value │ macro_source=273 │ [=] │ │ rowdata :: Identifier │ scope_layer=1 │ [call] │ │ DataFrame :: Identifier │ scope_layer=1 │ [kw] │ │ name :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ undef :: Identifier │ scope_layer=1 │ [ref] │ │ refdims :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=273 │ [=] │ │ coldata :: Identifier │ scope_layer=1 │ [call] │ │ DataFrame :: Identifier │ scope_layer=1 │ [kw] │ │ name :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ undef :: Identifier │ scope_layer=1 │ [ref] │ │ refdims :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=273 │ [call] │ │ new :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ rowdata :: Identifier │ scope_layer=1 │ coldata :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [inert] │ │ SummarizedExperiment :: Identifier │ │ [call] │ macro_source=273 │ Base.Docs.docstr :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Core.svec :: Value │ macro_source=273 │ " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Dict{Symbol, Any} :: Value │ macro_source=273 │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ :linenumber => 76 :: Value │ macro_source=273 │ :module => SummarizedExperiments :: Value │ macro_source=273 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ #2#val :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #3#val :: Identifier │ scope_layer=1 │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ [::] │ │ assays :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ [::] │ │ rowdata :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [::] │ │ coldata :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [kw] │ │ [::] │ │ metadata :: Identifier │ scope_layer=1 │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ refdims :: Identifier │ scope_layer=1 │ [tuple] │ │ [ref] │ │ [call] │ │ size :: Identifier │ scope_layer=1 │ rowdata :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=273 │ [ref] │ │ [call] │ │ size :: Identifier │ scope_layer=1 │ coldata :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=273 │ [for] │ │ [=] │ │ [tuple] │ │ key :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ check_assay_dimensions :: Identifier │ scope_layer=1 │ [call] │ │ size :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=1 │ refdims :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ DimensionMismatch :: Identifier │ scope_layer=1 │ [call] │ │ * :: Identifier │ scope_layer=1 │ "dimensions of 'assays[" :: Value │ macro_source=273 │ [call] │ │ repr :: Identifier │ scope_layer=1 │ key :: Identifier │ scope_layer=1 │ "]' are not consistent with 'rowdata' or 'coldata'" :: Value │ macro_source=273 │ [call] │ │ check_dataframe_in_constructor :: Identifier │ scope_layer=1 │ rowdata :: Identifier │ scope_layer=1 │ "rowdata" :: Value │ macro_source=273 │ [call] │ │ check_dataframe_in_constructor :: Identifier │ scope_layer=1 │ coldata :: Identifier │ scope_layer=1 │ "coldata" :: Value │ macro_source=273 │ [call] │ │ new :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ rowdata :: Identifier │ scope_layer=1 │ coldata :: Identifier │ scope_layer=1 │ metadata :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [inert] │ │ SummarizedExperiment :: Identifier │ │ [call] │ macro_source=273 │ Base.Docs.docstr :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Core.svec :: Value │ macro_source=273 │ " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Dict{Symbol, Any} :: Value │ macro_source=273 │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ :linenumber => 129 :: Value │ macro_source=273 │ :module => SummarizedExperiments :: Value │ macro_source=273 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ #3#val :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ │ [inert] │ jl_source=L65 │ SummarizedExperiment :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Core.svec :: Value │ macro_source=273 │ "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" :: Value │ macro_source=273 │ [call] │ │ Dict{Symbol, Any} :: Value │ macro_source=273 │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ :linenumber => 24 :: Value │ macro_source=273 │ :module => SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Pair :: Value │ macro_source=273 │ [inert] │ │ fields :: Identifier │ │ [call] │ macro_source=273 │ Dict{Symbol, Any} :: Value │ macro_source=273 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" │ line = 24 └ mod = SummarizedExperiments ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =# - assignment syntax in structure fields is reserved Expression:  (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) Containing expressions:  (block (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (:: metadata (curly Dict String Any)) (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) (call Base.Docs.doc! SummarizedExperiments (call Base.Docs.Binding SummarizedExperiments :SummarizedExperiment) (call Base.Docs.docstr (call Core.svec " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :linenumber => 47 :module => SummarizedExperiments)) (curly Union (curly Tuple))) #1#val (= #2#val (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray))) (block (if (call < (call length assays) 1) (block (call throw (call ErrorException "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied")))) (= refdims (call size (. (call first assays) :second))) (if (call < (call length refdims) 2) (block (call throw (call DimensionMismatch "'assays' should contain arrays with 2 or more dimensions")))) (= first_name (. (call first assays) :first)) (for (iteration (in (tuple key val) assays)) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "'assays[" (call repr key) "]' and 'assays[" (call repr first_name) "]' should have the same extents for the first 2 dimensions"))))))) (= rowdata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 1))))) (= coldata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 2))))) (call new assays rowdata coldata (call (curly Dict String Any)))))) (call Base.Docs.doc! SummarizedExperiments (call Base.Docs.Binding SummarizedExperiments :SummarizedExperiment) (call Base.Docs.docstr (call Core.svec " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :linenumber => 76 :module => SummarizedExperiments)) (curly Union (curly Tuple (curly OrderedDict String AbstractArray)))) #2#val (= #3#val (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (kw (:: metadata (curly Dict String Any)) (call (curly Dict String Any)))) (block (= refdims (tuple (ref (call size rowdata) 1) (ref (call size coldata) 1))) (for (iteration (in (tuple key val) assays)) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "dimensions of 'assays[" (call repr key) "]' are not consistent with 'rowdata' or 'coldata'"))))))) (call check_dataframe_in_constructor rowdata "rowdata") (call check_dataframe_in_constructor coldata "coldata") (call new assays rowdata coldata metadata)))) (call Base.Docs.doc! SummarizedExperiments (call Base.Docs.Binding SummarizedExperiments :SummarizedExperiment) (call Base.Docs.docstr (call Core.svec " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :linenumber => 129 :module => SummarizedExperiments)) (curly Union (curly Tuple (curly OrderedDict String AbstractArray) DataFrame DataFrame) (curly Tuple (curly OrderedDict String AbstractArray) DataFrame DataFrame (curly Dict String Any)))) #3#val)  Detailed provenance:  (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any))))))  └─ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any))))))  └─ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any))))))  └─ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any))))))  ├─ @ /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 =#) "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" (struct true SummarizedExperiment (block (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (:: metadata (curly Dict String Any)) (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =#) " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =#) " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray))) (block (if (call < (call length assays) 1) (block (call throw (call ErrorException "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied")))) (= refdims (call size (. (call first assays) (inert second)))) (if (call < (call length refdims) 2) (block (call throw (call DimensionMismatch "'assays' should contain arrays with 2 or more dimensions")))) (= first_name (. (call first assays) (inert first))) (for (= (tuple key val) assays) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "'assays[" (call repr key) "]' and 'assays[" (call repr first_name) "]' should have the same extents for the first 2 dimensions"))))))) (= rowdata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 1))))) (= coldata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 2))))) (call new assays rowdata coldata (call (curly Dict String Any)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =#) " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (kw (:: metadata (curly Dict String Any)) (call (curly Dict String Any)))) (block (= refdims (tuple (ref (call size rowdata) 1) (ref (call size coldata) 1))) (for (= (tuple key val) assays) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "dimensions of 'assays[" (call repr key) "]' are not consistent with 'rowdata' or 'coldata'"))))))) (call check_dataframe_in_constructor rowdata "rowdata") (call check_dataframe_in_constructor coldata "coldata") (call new assays rowdata coldata metadata)))))))  └─ @ /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24  Stacktrace:  [1] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3166  [2] expand_struct_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3736  [3] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4317  [4] expand_assignment(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, is_const::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:1320  [5] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4177  [6] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4133 [inlined]  [7] (::Base.JuliaLowering.var"#expand_forms_2##2#expand_forms_2##3"{Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}})(e::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4421 [inlined]  [8] mapchildren(f::Base.JuliaLowering.var"#expand_forms_2##2#expand_forms_2##3"{Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}}, ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:707  [9] getindex(A::Vector{UnitRange{Int64}}, i::Int64)  @ Base essentials.jl:1040 [inlined]  [10] numchildren(graph::Base.JuliaSyntax.SyntaxGraph{Dict{Symbol, Dict{Int64, Any}}}, id::Int64)  @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:121 [inlined]  [11] numchildren(ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:306 [inlined]  [12] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4268  [13] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4133 [inlined]  [14] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4450  [15] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:30  [16] include(mapexpr::Function, mod::Module, _path::String)  @ Base Base.jl:327  [17] top-level scope  @ ~/.julia/packages/SummarizedExperiments/Nxbzn/src/SummarizedExperiments.jl:7  [18] include(mod::Module, _path::String)  @ Base Base.jl:326  [19] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3296  [20] top-level scope  @ stdin:5  [21] eval(m::Module, e::Any)  @ Core boot.jl:521  [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [23] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [24] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [25] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 in expression starting at /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/SummarizedExperiments.jl:1 in expression starting at stdin:5 ✗ SummarizedExperiments ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("b04b66ec-f619-4ebf-810e-cf5ccc546695"), "SummarizedExperiments") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0) Stacktrace:  [1] error(s::String)  @ Base error.jl:56  [2] __require_prelocked(pkg::Base.PkgId, env::String)  @ Base loading.jl:2837  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)  @ Base loading.jl:2685  [4] macro expansion  @ loading.jl:2599 [inlined]  [5] macro expansion  @ lock.jl:376 [inlined]  [6] __require(into::Module, mod::Symbol)  @ Base loading.jl:2563  [7] require(into::Module, mod::Symbol)  @ Base loading.jl:2539 [inlined]  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)  @ Base module.jl:36 [inlined]  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)  @ Base module.jl:60  [10] _eval_using(to::Module, path::Expr, flags::UInt8)  @ Base module.jl:137 [inlined]  [11] eval_using(to::Module, path::Expr)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/runtime.jl:207  [12] top-level scope  @ ~/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:4  [13] macro expansion  @ ~/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:4 [inlined]  [14] eval(m::Module, e::Any)  @ Core boot.jl:521  [15] _eval(mod::Module, iter::Base.JuliaLowering.LoweringIterator{Dict{Symbol, Dict{Int64, Any}}}; soft_scope::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:545  [16] eval(mod::Module, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}; macro_world::UInt64, soft_scope::Nothing, opts::@Kwargs{expr_compat_mode::Bool})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:518 [inlined]  [17] top-level scope  @ ~/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:4  [18] macro expansion  @ ~/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:4 [inlined]  [19] include(mod::Module, _path::String)  @ Base Base.jl:326  [20] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3296  [21] top-level scope  @ stdin:5  [22] eval(m::Module, e::Any)  @ Core boot.jl:521  [23] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [24] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [25] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [26] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:1 in expression starting at stdin:5 ✗ MultiAssayExperiments 24 dependencies successfully precompiled in 2043 seconds. 12 already precompiled. Precompilation completed after 2061.68s ################################################################################ # Loading # Loading MultiAssayExperiments... ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 =# Core.@doc "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" mutable struct SummarizedExperiment │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:42 =# │ assays::OrderedDict{String, AbstractArray} │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:43 =# │ rowdata::DataFrame │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:44 =# │ coldata::DataFrame │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:45 =# │ metadata::Dict{String, Any} │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =# @doc " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" function SummarizedExperiment() │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:66 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:67 =# │ dummy = DataFrame(name = String[]) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:68 =# │ new(OrderedDict{String, AbstractArray}(), dummy, deepcopy(dummy), Dict{String, Any}()) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =# @doc " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" function SummarizedExperiment(assays::OrderedDict{String, AbstractArray}) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:106 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:107 =# │ if length(assays) < 1 │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:108 =# │ throw(ErrorException("expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied")) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:111 =# │ refdims = size((first(assays)).second) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:112 =# │ if length(refdims) < 2 │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:113 =# │ throw(DimensionMismatch("'assays' should contain arrays with 2 or more dimensions")) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:116 =# │ first_name = (first(assays)).first │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:117 =# │ for (key, val) = assays │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:118 =# │ if !(check_assay_dimensions(size(val), refdims)) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:119 =# │ throw(DimensionMismatch("'assays[" * repr(key) * "]' and 'assays[" * repr(first_name) * "]' should have the same extents for the first 2 dimensions")) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:122 =# │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:124 =# │ rowdata = DataFrame(name = Vector{Nothing}(undef, refdims[1])) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:125 =# │ coldata = DataFrame(name = Vector{Nothing}(undef, refdims[2])) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:126 =# │ new(assays, rowdata, coldata, Dict{String, Any}()) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =# @doc " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" function SummarizedExperiment(assays::OrderedDict{String, AbstractArray}, rowdata::DataFrame, coldata::DataFrame, metadata::Dict{String, Any} = Dict{String, Any}()) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:170 =# │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:177 =# │ refdims = ((size(rowdata))[1], (size(coldata))[1]) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:179 =# │ for (key, val) = assays │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:180 =# │ if !(check_assay_dimensions(size(val), refdims)) │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:181 =# │ throw(DimensionMismatch("dimensions of 'assays[" * repr(key) * "]' are not consistent with 'rowdata' or 'coldata'")) │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:183 =# │ end │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:185 =# │ check_dataframe_in_constructor(rowdata, "rowdata") │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:186 =# │ check_dataframe_in_constructor(coldata, "coldata") │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:187 =# │ new(assays, rowdata, coldata, metadata) │ end │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 =#) :: Value │ │ "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" :: Value │ │ [struct] │ │ true :: Value │ │ SummarizedExperiment :: Identifier │ │ [block] │ │ [::] │ │ assays :: Identifier │ │ [curly] │ │ OrderedDict :: Identifier │ │ String :: Identifier │ │ AbstractArray :: Identifier │ │ [::] │ │ rowdata :: Identifier │ │ DataFrame :: Identifier │ │ [::] │ │ coldata :: Identifier │ │ DataFrame :: Identifier │ │ [::] │ │ metadata :: Identifier │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =#) :: Value │ │ " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ │ [block] │ │ [=] │ │ dummy :: Identifier │ │ [call] │ │ DataFrame :: Identifier │ │ [kw] │ │ name :: Identifier │ │ [ref] │ │ String :: Identifier │ │ [call] │ │ new :: Identifier │ │ [call] │ │ [curly] │ │ OrderedDict :: Identifier │ │ String :: Identifier │ │ AbstractArray :: Identifier │ │ dummy :: Identifier │ │ [call] │ │ deepcopy :: Identifier │ │ dummy :: Identifier │ │ [call] │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =#) :: Value │ │ " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ │ [::] │ │ assays :: Identifier │ │ [curly] │ │ OrderedDict :: Identifier │ │ String :: Identifier │ │ AbstractArray :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ < :: Identifier │ │ [call] │ │ length :: Identifier │ │ assays :: Identifier │ │ 1 :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ ErrorException :: Identifier │ │ "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied" :: Value │ │ [=] │ │ refdims :: Identifier │ │ [call] │ │ size :: Identifier │ │ [.] │ │ [call] │ │ first :: Identifier │ │ assays :: Identifier │ │ [inert] │ │ second :: Identifier │ │ [if] │ │ [call] │ │ < :: Identifier │ │ [call] │ │ length :: Identifier │ │ refdims :: Identifier │ │ 2 :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ DimensionMismatch :: Identifier │ │ "'assays' should contain arrays with 2 or more dimensions" :: Value │ │ [=] │ │ first_name :: Identifier │ │ [.] │ │ [call] │ │ first :: Identifier │ │ assays :: Identifier │ │ [inert] │ │ first :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ key :: Identifier │ │ val :: Identifier │ │ assays :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ check_assay_dimensions :: Identifier │ │ [call] │ │ size :: Identifier │ │ val :: Identifier │ │ refdims :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ DimensionMismatch :: Identifier │ │ [call] │ │ * :: Identifier │ │ "'assays[" :: Value │ │ [call] │ │ repr :: Identifier │ │ key :: Identifier │ │ "]' and 'assays[" :: Value │ │ [call] │ │ repr :: Identifier │ │ first_name :: Identifier │ │ "]' should have the same extents for the first 2 dimensions" :: Value │ │ [=] │ │ rowdata :: Identifier │ │ [call] │ │ DataFrame :: Identifier │ │ [kw] │ │ name :: Identifier │ │ [call] │ │ [curly] │ │ Vector :: Identifier │ │ Nothing :: Identifier │ │ undef :: Identifier │ │ [ref] │ │ refdims :: Identifier │ │ 1 :: Value │ │ [=] │ │ coldata :: Identifier │ │ [call] │ │ DataFrame :: Identifier │ │ [kw] │ │ name :: Identifier │ │ [call] │ │ [curly] │ │ Vector :: Identifier │ │ Nothing :: Identifier │ │ undef :: Identifier │ │ [ref] │ │ refdims :: Identifier │ │ 2 :: Value │ │ [call] │ │ new :: Identifier │ │ assays :: Identifier │ │ rowdata :: Identifier │ │ coldata :: Identifier │ │ [call] │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =#) :: Value │ │ " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" :: Value │ │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ │ [::] │ │ assays :: Identifier │ │ [curly] │ │ OrderedDict :: Identifier │ │ String :: Identifier │ │ AbstractArray :: Identifier │ │ [::] │ │ rowdata :: Identifier │ │ DataFrame :: Identifier │ │ [::] │ │ coldata :: Identifier │ │ DataFrame :: Identifier │ │ [kw] │ │ [::] │ │ metadata :: Identifier │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [call] │ │ [curly] │ │ Dict :: Identifier │ │ String :: Identifier │ │ Any :: Identifier │ │ [block] │ │ [=] │ │ refdims :: Identifier │ │ [tuple] │ │ [ref] │ │ [call] │ │ size :: Identifier │ │ rowdata :: Identifier │ │ 1 :: Value │ │ [ref] │ │ [call] │ │ size :: Identifier │ │ coldata :: Identifier │ │ 1 :: Value │ │ [for] │ │ [=] │ │ [tuple] │ │ key :: Identifier │ │ val :: Identifier │ │ assays :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ check_assay_dimensions :: Identifier │ │ [call] │ │ size :: Identifier │ │ val :: Identifier │ │ refdims :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ DimensionMismatch :: Identifier │ │ [call] │ │ * :: Identifier │ │ "dimensions of 'assays[" :: Value │ │ [call] │ │ repr :: Identifier │ │ key :: Identifier │ │ "]' are not consistent with 'rowdata' or 'coldata'" :: Value │ │ [call] │ │ check_dataframe_in_constructor :: Identifier │ │ rowdata :: Identifier │ │ "rowdata" :: Value │ │ [call] │ │ check_dataframe_in_constructor :: Identifier │ │ coldata :: Identifier │ │ "coldata" :: Value │ │ [call] │ │ new :: Identifier │ │ assays :: Identifier │ │ rowdata :: Identifier │ │ coldata :: Identifier │ │ metadata :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [struct] │ │ true :: Value │ macro_source=273 │ SummarizedExperiment :: Identifier │ scope_layer=1 │ [block] │ │ [::] │ │ assays :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ [::] │ │ rowdata :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [::] │ │ coldata :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [::] │ │ metadata :: Identifier │ scope_layer=1 │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #1#val :: Identifier │ scope_layer=1 │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ dummy :: Identifier │ scope_layer=1 │ [call] │ │ DataFrame :: Identifier │ scope_layer=1 │ [kw] │ │ name :: Identifier │ scope_layer=1 │ [ref] │ │ String :: Identifier │ scope_layer=1 │ [call] │ │ new :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ dummy :: Identifier │ scope_layer=1 │ [call] │ │ deepcopy :: Identifier │ scope_layer=1 │ dummy :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [inert] │ │ SummarizedExperiment :: Identifier │ │ [call] │ macro_source=273 │ Base.Docs.docstr :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Core.svec :: Value │ macro_source=273 │ " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Dict{Symbol, Any} :: Value │ macro_source=273 │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ :linenumber => 47 :: Value │ macro_source=273 │ :module => SummarizedExperiments :: Value │ macro_source=273 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ #1#val :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #2#val :: Identifier │ scope_layer=1 │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ [::] │ │ assays :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ < :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=273 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ ErrorException :: Identifier │ scope_layer=1 │ "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied" :: Value │ macro_source=273 │ [=] │ │ refdims :: Identifier │ scope_layer=1 │ [call] │ │ size :: Identifier │ scope_layer=1 │ [.] │ │ [call] │ │ first :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ [inert] │ │ second :: Identifier │ │ [if] │ │ [call] │ │ < :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ refdims :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=273 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ DimensionMismatch :: Identifier │ scope_layer=1 │ "'assays' should contain arrays with 2 or more dimensions" :: Value │ macro_source=273 │ [=] │ │ first_name :: Identifier │ scope_layer=1 │ [.] │ │ [call] │ │ first :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ [inert] │ │ first :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ key :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ check_assay_dimensions :: Identifier │ scope_layer=1 │ [call] │ │ size :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=1 │ refdims :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ DimensionMismatch :: Identifier │ scope_layer=1 │ [call] │ │ * :: Identifier │ scope_layer=1 │ "'assays[" :: Value │ macro_source=273 │ [call] │ │ repr :: Identifier │ scope_layer=1 │ key :: Identifier │ scope_layer=1 │ "]' and 'assays[" :: Value │ macro_source=273 │ [call] │ │ repr :: Identifier │ scope_layer=1 │ first_name :: Identifier │ scope_layer=1 │ "]' should have the same extents for the first 2 dimensions" :: Value │ macro_source=273 │ [=] │ │ rowdata :: Identifier │ scope_layer=1 │ [call] │ │ DataFrame :: Identifier │ scope_layer=1 │ [kw] │ │ name :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ undef :: Identifier │ scope_layer=1 │ [ref] │ │ refdims :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=273 │ [=] │ │ coldata :: Identifier │ scope_layer=1 │ [call] │ │ DataFrame :: Identifier │ scope_layer=1 │ [kw] │ │ name :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ Nothing :: Identifier │ scope_layer=1 │ undef :: Identifier │ scope_layer=1 │ [ref] │ │ refdims :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=273 │ [call] │ │ new :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ rowdata :: Identifier │ scope_layer=1 │ coldata :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [inert] │ │ SummarizedExperiment :: Identifier │ │ [call] │ macro_source=273 │ Base.Docs.docstr :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Core.svec :: Value │ macro_source=273 │ " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Dict{Symbol, Any} :: Value │ macro_source=273 │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ :linenumber => 76 :: Value │ macro_source=273 │ :module => SummarizedExperiments :: Value │ macro_source=273 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ #2#val :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #3#val :: Identifier │ scope_layer=1 │ [function] │ │ [call] │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ [::] │ │ assays :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ [::] │ │ rowdata :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [::] │ │ coldata :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [kw] │ │ [::] │ │ metadata :: Identifier │ scope_layer=1 │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ refdims :: Identifier │ scope_layer=1 │ [tuple] │ │ [ref] │ │ [call] │ │ size :: Identifier │ scope_layer=1 │ rowdata :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=273 │ [ref] │ │ [call] │ │ size :: Identifier │ scope_layer=1 │ coldata :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=273 │ [for] │ │ [=] │ │ [tuple] │ │ key :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ check_assay_dimensions :: Identifier │ scope_layer=1 │ [call] │ │ size :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=1 │ refdims :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ DimensionMismatch :: Identifier │ scope_layer=1 │ [call] │ │ * :: Identifier │ scope_layer=1 │ "dimensions of 'assays[" :: Value │ macro_source=273 │ [call] │ │ repr :: Identifier │ scope_layer=1 │ key :: Identifier │ scope_layer=1 │ "]' are not consistent with 'rowdata' or 'coldata'" :: Value │ macro_source=273 │ [call] │ │ check_dataframe_in_constructor :: Identifier │ scope_layer=1 │ rowdata :: Identifier │ scope_layer=1 │ "rowdata" :: Value │ macro_source=273 │ [call] │ │ check_dataframe_in_constructor :: Identifier │ scope_layer=1 │ coldata :: Identifier │ scope_layer=1 │ "coldata" :: Value │ macro_source=273 │ [call] │ │ new :: Identifier │ scope_layer=1 │ assays :: Identifier │ scope_layer=1 │ rowdata :: Identifier │ scope_layer=1 │ coldata :: Identifier │ scope_layer=1 │ metadata :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [inert] │ │ SummarizedExperiment :: Identifier │ │ [call] │ macro_source=273 │ Base.Docs.docstr :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Core.svec :: Value │ macro_source=273 │ " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Dict{Symbol, Any} :: Value │ macro_source=273 │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ :linenumber => 129 :: Value │ macro_source=273 │ :module => SummarizedExperiments :: Value │ macro_source=273 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [curly] │ │ OrderedDict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ AbstractArray :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ DataFrame :: Identifier │ scope_layer=1 │ [curly] │ │ Dict :: Identifier │ scope_layer=1 │ String :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ #3#val :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=273 │ SummarizedExperiments :: Value │ │ [inert] │ jl_source=L65 │ SummarizedExperiment :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=273 │ [call] │ macro_source=273 │ Core.svec :: Value │ macro_source=273 │ "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" :: Value │ macro_source=273 │ [call] │ │ Dict{Symbol, Any} :: Value │ macro_source=273 │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ :linenumber => 24 :: Value │ macro_source=273 │ :module => SummarizedExperiments :: Value │ macro_source=273 │ [call] │ │ Pair :: Value │ macro_source=273 │ [inert] │ │ fields :: Identifier │ │ [call] │ macro_source=273 │ Dict{Symbol, Any} :: Value │ macro_source=273 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" │ line = 24 └ mod = SummarizedExperiments ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =# - assignment syntax in structure fields is reserved Expression:  (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) Containing expressions:  (block (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (:: metadata (curly Dict String Any)) (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) (call Base.Docs.doc! SummarizedExperiments (call Base.Docs.Binding SummarizedExperiments :SummarizedExperiment) (call Base.Docs.docstr (call Core.svec " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :linenumber => 47 :module => SummarizedExperiments)) (curly Union (curly Tuple))) #1#val (= #2#val (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray))) (block (if (call < (call length assays) 1) (block (call throw (call ErrorException "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied")))) (= refdims (call size (. (call first assays) :second))) (if (call < (call length refdims) 2) (block (call throw (call DimensionMismatch "'assays' should contain arrays with 2 or more dimensions")))) (= first_name (. (call first assays) :first)) (for (iteration (in (tuple key val) assays)) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "'assays[" (call repr key) "]' and 'assays[" (call repr first_name) "]' should have the same extents for the first 2 dimensions"))))))) (= rowdata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 1))))) (= coldata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 2))))) (call new assays rowdata coldata (call (curly Dict String Any)))))) (call Base.Docs.doc! SummarizedExperiments (call Base.Docs.Binding SummarizedExperiments :SummarizedExperiment) (call Base.Docs.docstr (call Core.svec " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :linenumber => 76 :module => SummarizedExperiments)) (curly Union (curly Tuple (curly OrderedDict String AbstractArray)))) #2#val (= #3#val (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (kw (:: metadata (curly Dict String Any)) (call (curly Dict String Any)))) (block (= refdims (tuple (ref (call size rowdata) 1) (ref (call size coldata) 1))) (for (iteration (in (tuple key val) assays)) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "dimensions of 'assays[" (call repr key) "]' are not consistent with 'rowdata' or 'coldata'"))))))) (call check_dataframe_in_constructor rowdata "rowdata") (call check_dataframe_in_constructor coldata "coldata") (call new assays rowdata coldata metadata)))) (call Base.Docs.doc! SummarizedExperiments (call Base.Docs.Binding SummarizedExperiments :SummarizedExperiment) (call Base.Docs.docstr (call Core.svec " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :linenumber => 129 :module => SummarizedExperiments)) (curly Union (curly Tuple (curly OrderedDict String AbstractArray) DataFrame DataFrame) (curly Tuple (curly OrderedDict String AbstractArray) DataFrame DataFrame (curly Dict String Any)))) #3#val)  Detailed provenance:  (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any))))))  └─ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any))))))  └─ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any))))))  └─ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any))))))  ├─ @ /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 =#) "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" (struct true SummarizedExperiment (block (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (:: metadata (curly Dict String Any)) (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =#) " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =#) " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray))) (block (if (call < (call length assays) 1) (block (call throw (call ErrorException "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied")))) (= refdims (call size (. (call first assays) (inert second)))) (if (call < (call length refdims) 2) (block (call throw (call DimensionMismatch "'assays' should contain arrays with 2 or more dimensions")))) (= first_name (. (call first assays) (inert first))) (for (= (tuple key val) assays) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "'assays[" (call repr key) "]' and 'assays[" (call repr first_name) "]' should have the same extents for the first 2 dimensions"))))))) (= rowdata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 1))))) (= coldata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 2))))) (call new assays rowdata coldata (call (curly Dict String Any)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =#) " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (kw (:: metadata (curly Dict String Any)) (call (curly Dict String Any)))) (block (= refdims (tuple (ref (call size rowdata) 1) (ref (call size coldata) 1))) (for (= (tuple key val) assays) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "dimensions of 'assays[" (call repr key) "]' are not consistent with 'rowdata' or 'coldata'"))))))) (call check_dataframe_in_constructor rowdata "rowdata") (call check_dataframe_in_constructor coldata "coldata") (call new assays rowdata coldata metadata)))))))  └─ @ /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24  Stacktrace:  [1] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3166  [2] expand_struct_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3736  [3] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4317  [4] expand_assignment(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, is_const::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:1320  [5] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4177  [6] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4133 [inlined]  [7] (::Base.JuliaLowering.var"#expand_forms_2##2#expand_forms_2##3"{Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}})(e::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4421 [inlined]  [8] mapchildren(f::Base.JuliaLowering.var"#expand_forms_2##2#expand_forms_2##3"{Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}}, ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:707  [9] getindex(A::Vector{UnitRange{Int64}}, i::Int64)  @ Base essentials.jl:1040 [inlined]  [10] numchildren(graph::Base.JuliaSyntax.SyntaxGraph{Dict{Symbol, Dict{Int64, Any}}}, id::Int64)  @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:121 [inlined]  [11] numchildren(ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:306 [inlined]  [12] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4268  [13] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4133 [inlined]  [14] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4450  [15] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:30  [16] include(mapexpr::Function, mod::Module, _path::String)  @ Base Base.jl:327  [17] top-level scope  @ ~/.julia/packages/SummarizedExperiments/Nxbzn/src/SummarizedExperiments.jl:7  [18] include(mod::Module, _path::String)  @ Base Base.jl:326  [19] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3296  [20] top-level scope  @ stdin:5  [21] eval(m::Module, e::Any)  @ Core boot.jl:521  [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [23] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [24] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [25] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 in expression starting at /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/SummarizedExperiments.jl:1 in expression starting at stdin:5 ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("b04b66ec-f619-4ebf-810e-cf5ccc546695"), "SummarizedExperiments") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0) Stacktrace:  [1] error(s::String)  @ Base error.jl:56  [2] __require_prelocked(pkg::Base.PkgId, env::String)  @ Base loading.jl:2837  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)  @ Base loading.jl:2685  [4] macro expansion  @ loading.jl:2599 [inlined]  [5] macro expansion  @ lock.jl:376 [inlined]  [6] __require(into::Module, mod::Symbol)  @ Base loading.jl:2563  [7] require(into::Module, mod::Symbol)  @ Base loading.jl:2539 [inlined]  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)  @ Base module.jl:36 [inlined]  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)  @ Base module.jl:60  [10] _eval_using(to::Module, path::Expr, flags::UInt8)  @ Base module.jl:137 [inlined]  [11] eval_using(to::Module, path::Expr)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/runtime.jl:207  [12] top-level scope  @ ~/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:4  [13] macro expansion  @ ~/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:4 [inlined]  [14] eval(m::Module, e::Any)  @ Core boot.jl:521  [15] _eval(mod::Module, iter::Base.JuliaLowering.LoweringIterator{Dict{Symbol, Dict{Int64, Any}}}; soft_scope::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:545  [16] eval(mod::Module, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}; macro_world::UInt64, soft_scope::Nothing, opts::@Kwargs{expr_compat_mode::Bool})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:518 [inlined]  [17] top-level scope  @ ~/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:4  [18] macro expansion  @ ~/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:4 [inlined]  [19] include(mod::Module, _path::String)  @ Base Base.jl:326  [20] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3296  [21] top-level scope  @ stdin:5  [22] eval(m::Module, e::Any)  @ Core boot.jl:521  [23] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [24] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [25] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [26] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/MultiAssayExperiments/VHg1a/src/MultiAssayExperiments.jl:1 in expression starting at stdin:5 2 dependencies had output during precompilation: ┌ MultiAssayExperiments │ [Output was shown above] └ ┌ SummarizedExperiments │ ┌ Info: JuliaLowering threw given input: │ │ code = │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 =# Core.@doc "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" mutable struct SummarizedExperiment │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:42 =# │ │ assays::OrderedDict{String, AbstractArray} │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:43 =# │ │ rowdata::DataFrame │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:44 =# │ │ coldata::DataFrame │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:45 =# │ │ metadata::Dict{String, Any} │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =# │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =# @doc " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" function SummarizedExperiment() │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:66 =# │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:67 =# │ │ dummy = DataFrame(name = String[]) │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:68 =# │ │ new(OrderedDict{String, AbstractArray}(), dummy, deepcopy(dummy), Dict{String, Any}()) │ │ end │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =# │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =# @doc " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" function SummarizedExperiment(assays::OrderedDict{String, AbstractArray}) │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:106 =# │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:107 =# │ │ if length(assays) < 1 │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:108 =# │ │ throw(ErrorException("expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied")) │ │ end │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:111 =# │ │ refdims = size((first(assays)).second) │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:112 =# │ │ if length(refdims) < 2 │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:113 =# │ │ throw(DimensionMismatch("'assays' should contain arrays with 2 or more dimensions")) │ │ end │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:116 =# │ │ first_name = (first(assays)).first │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:117 =# │ │ for (key, val) = assays │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:118 =# │ │ if !(check_assay_dimensions(size(val), refdims)) │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:119 =# │ │ throw(DimensionMismatch("'assays[" * repr(key) * "]' and 'assays[" * repr(first_name) * "]' should have the same extents for the first 2 dimensions")) │ │ end │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:122 =# │ │ end │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:124 =# │ │ rowdata = DataFrame(name = Vector{Nothing}(undef, refdims[1])) │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:125 =# │ │ coldata = DataFrame(name = Vector{Nothing}(undef, refdims[2])) │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:126 =# │ │ new(assays, rowdata, coldata, Dict{String, Any}()) │ │ end │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =# │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =# @doc " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" function SummarizedExperiment(assays::OrderedDict{String, AbstractArray}, rowdata::DataFrame, coldata::DataFrame, metadata::Dict{String, Any} = Dict{String, Any}()) │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:170 =# │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:177 =# │ │ refdims = ((size(rowdata))[1], (size(coldata))[1]) │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:179 =# │ │ for (key, val) = assays │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:180 =# │ │ if !(check_assay_dimensions(size(val), refdims)) │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:181 =# │ │ throw(DimensionMismatch("dimensions of 'assays[" * repr(key) * "]' are not consistent with 'rowdata' or 'coldata'")) │ │ end │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:183 =# │ │ end │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:185 =# │ │ check_dataframe_in_constructor(rowdata, "rowdata") │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:186 =# │ │ check_dataframe_in_constructor(coldata, "coldata") │ │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:187 =# │ │ new(assays, rowdata, coldata, metadata) │ │ end │ │ end) │ │ st0 = │ │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ │ [macrocall] │ │ │ @doc :: Identifier │ mod │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 =#) :: Value │ │ │ "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" :: Value │ │ │ [struct] │ │ │ true :: Value │ │ │ SummarizedExperiment :: Identifier │ │ │ [block] │ │ │ [::] │ │ │ assays :: Identifier │ │ │ [curly] │ │ │ OrderedDict :: Identifier │ │ │ String :: Identifier │ │ │ AbstractArray :: Identifier │ │ │ [::] │ │ │ rowdata :: Identifier │ │ │ DataFrame :: Identifier │ │ │ [::] │ │ │ coldata :: Identifier │ │ │ DataFrame :: Identifier │ │ │ [::] │ │ │ metadata :: Identifier │ │ │ [curly] │ │ │ Dict :: Identifier │ │ │ String :: Identifier │ │ │ Any :: Identifier │ │ │ [macrocall] │ │ │ @doc :: Identifier │ │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =#) :: Value │ │ │ " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ │ │ [function] │ │ │ [call] │ │ │ SummarizedExperiment :: Identifier │ │ │ [block] │ │ │ [=] │ │ │ dummy :: Identifier │ │ │ [call] │ │ │ DataFrame :: Identifier │ │ │ [kw] │ │ │ name :: Identifier │ │ │ [ref] │ │ │ String :: Identifier │ │ │ [call] │ │ │ new :: Identifier │ │ │ [call] │ │ │ [curly] │ │ │ OrderedDict :: Identifier │ │ │ String :: Identifier │ │ │ AbstractArray :: Identifier │ │ │ dummy :: Identifier │ │ │ [call] │ │ │ deepcopy :: Identifier │ │ │ dummy :: Identifier │ │ │ [call] │ │ │ [curly] │ │ │ Dict :: Identifier │ │ │ String :: Identifier │ │ │ Any :: Identifier │ │ │ [macrocall] │ │ │ @doc :: Identifier │ │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =#) :: Value │ │ │ " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ │ │ [function] │ │ │ [call] │ │ │ SummarizedExperiment :: Identifier │ │ │ [::] │ │ │ assays :: Identifier │ │ │ [curly] │ │ │ OrderedDict :: Identifier │ │ │ String :: Identifier │ │ │ AbstractArray :: Identifier │ │ │ [block] │ │ │ [if] │ │ │ [call] │ │ │ < :: Identifier │ │ │ [call] │ │ │ length :: Identifier │ │ │ assays :: Identifier │ │ │ 1 :: Value │ │ │ [block] │ │ │ [call] │ │ │ throw :: Identifier │ │ │ [call] │ │ │ ErrorException :: Identifier │ │ │ "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied" :: Value │ │ │ [=] │ │ │ refdims :: Identifier │ │ │ [call] │ │ │ size :: Identifier │ │ │ [.] │ │ │ [call] │ │ │ first :: Identifier │ │ │ assays :: Identifier │ │ │ [inert] │ │ │ second :: Identifier │ │ │ [if] │ │ │ [call] │ │ │ < :: Identifier │ │ │ [call] │ │ │ length :: Identifier │ │ │ refdims :: Identifier │ │ │ 2 :: Value │ │ │ [block] │ │ │ [call] │ │ │ throw :: Identifier │ │ │ [call] │ │ │ DimensionMismatch :: Identifier │ │ │ "'assays' should contain arrays with 2 or more dimensions" :: Value │ │ │ [=] │ │ │ first_name :: Identifier │ │ │ [.] │ │ │ [call] │ │ │ first :: Identifier │ │ │ assays :: Identifier │ │ │ [inert] │ │ │ first :: Identifier │ │ │ [for] │ │ │ [=] │ │ │ [tuple] │ │ │ key :: Identifier │ │ │ val :: Identifier │ │ │ assays :: Identifier │ │ │ [block] │ │ │ [if] │ │ │ [call] │ │ │ ! :: Identifier │ │ │ [call] │ │ │ check_assay_dimensions :: Identifier │ │ │ [call] │ │ │ size :: Identifier │ │ │ val :: Identifier │ │ │ refdims :: Identifier │ │ │ [block] │ │ │ [call] │ │ │ throw :: Identifier │ │ │ [call] │ │ │ DimensionMismatch :: Identifier │ │ │ [call] │ │ │ * :: Identifier │ │ │ "'assays[" :: Value │ │ │ [call] │ │ │ repr :: Identifier │ │ │ key :: Identifier │ │ │ "]' and 'assays[" :: Value │ │ │ [call] │ │ │ repr :: Identifier │ │ │ first_name :: Identifier │ │ │ "]' should have the same extents for the first 2 dimensions" :: Value │ │ │ [=] │ │ │ rowdata :: Identifier │ │ │ [call] │ │ │ DataFrame :: Identifier │ │ │ [kw] │ │ │ name :: Identifier │ │ │ [call] │ │ │ [curly] │ │ │ Vector :: Identifier │ │ │ Nothing :: Identifier │ │ │ undef :: Identifier │ │ │ [ref] │ │ │ refdims :: Identifier │ │ │ 1 :: Value │ │ │ [=] │ │ │ coldata :: Identifier │ │ │ [call] │ │ │ DataFrame :: Identifier │ │ │ [kw] │ │ │ name :: Identifier │ │ │ [call] │ │ │ [curly] │ │ │ Vector :: Identifier │ │ │ Nothing :: Identifier │ │ │ undef :: Identifier │ │ │ [ref] │ │ │ refdims :: Identifier │ │ │ 2 :: Value │ │ │ [call] │ │ │ new :: Identifier │ │ │ assays :: Identifier │ │ │ rowdata :: Identifier │ │ │ coldata :: Identifier │ │ │ [call] │ │ │ [curly] │ │ │ Dict :: Identifier │ │ │ String :: Identifier │ │ │ Any :: Identifier │ │ │ [macrocall] │ │ │ @doc :: Identifier │ │ │ :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =#) :: Value │ │ │ " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" :: Value │ │ │ [function] │ │ │ [call] │ │ │ SummarizedExperiment :: Identifier │ │ │ [::] │ │ │ assays :: Identifier │ │ │ [curly] │ │ │ OrderedDict :: Identifier │ │ │ String :: Identifier │ │ │ AbstractArray :: Identifier │ │ │ [::] │ │ │ rowdata :: Identifier │ │ │ DataFrame :: Identifier │ │ │ [::] │ │ │ coldata :: Identifier │ │ │ DataFrame :: Identifier │ │ │ [kw] │ │ │ [::] │ │ │ metadata :: Identifier │ │ │ [curly] │ │ │ Dict :: Identifier │ │ │ String :: Identifier │ │ │ Any :: Identifier │ │ │ [call] │ │ │ [curly] │ │ │ Dict :: Identifier │ │ │ String :: Identifier │ │ │ Any :: Identifier │ │ │ [block] │ │ │ [=] │ │ │ refdims :: Identifier │ │ │ [tuple] │ │ │ [ref] │ │ │ [call] │ │ │ size :: Identifier │ │ │ rowdata :: Identifier │ │ │ 1 :: Value │ │ │ [ref] │ │ │ [call] │ │ │ size :: Identifier │ │ │ coldata :: Identifier │ │ │ 1 :: Value │ │ │ [for] │ │ │ [=] │ │ │ [tuple] │ │ │ key :: Identifier │ │ │ val :: Identifier │ │ │ assays :: Identifier │ │ │ [block] │ │ │ [if] │ │ │ [call] │ │ │ ! :: Identifier │ │ │ [call] │ │ │ check_assay_dimensions :: Identifier │ │ │ [call] │ │ │ size :: Identifier │ │ │ val :: Identifier │ │ │ refdims :: Identifier │ │ │ [block] │ │ │ [call] │ │ │ throw :: Identifier │ │ │ [call] │ │ │ DimensionMismatch :: Identifier │ │ │ [call] │ │ │ * :: Identifier │ │ │ "dimensions of 'assays[" :: Value │ │ │ [call] │ │ │ repr :: Identifier │ │ │ key :: Identifier │ │ │ "]' are not consistent with 'rowdata' or 'coldata'" :: Value │ │ │ [call] │ │ │ check_dataframe_in_constructor :: Identifier │ │ │ rowdata :: Identifier │ │ │ "rowdata" :: Value │ │ │ [call] │ │ │ check_dataframe_in_constructor :: Identifier │ │ │ coldata :: Identifier │ │ │ "coldata" :: Value │ │ │ [call] │ │ │ new :: Identifier │ │ │ assays :: Identifier │ │ │ rowdata :: Identifier │ │ │ coldata :: Identifier │ │ │ metadata :: Identifier │ │ │ │ │ st1 = │ │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ │ [block] │ │ │ [=] │ │ │ val :: Identifier │ scope_layer=3 │ │ [struct] │ │ │ true :: Value │ macro_source=273 │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [::] │ │ │ assays :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ OrderedDict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ AbstractArray :: Identifier │ scope_layer=1 │ │ [::] │ │ │ rowdata :: Identifier │ scope_layer=1 │ │ DataFrame :: Identifier │ scope_layer=1 │ │ [::] │ │ │ coldata :: Identifier │ scope_layer=1 │ │ DataFrame :: Identifier │ scope_layer=1 │ │ [::] │ │ │ metadata :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ Dict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ Any :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [=] │ │ │ #1#val :: Identifier │ scope_layer=1 │ │ [function] │ │ │ [call] │ │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [=] │ │ │ dummy :: Identifier │ scope_layer=1 │ │ [call] │ │ │ DataFrame :: Identifier │ scope_layer=1 │ │ [kw] │ │ │ name :: Identifier │ scope_layer=1 │ │ [ref] │ │ │ String :: Identifier │ scope_layer=1 │ │ [call] │ │ │ new :: Identifier │ scope_layer=1 │ │ [call] │ │ │ [curly] │ │ │ OrderedDict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ AbstractArray :: Identifier │ scope_layer=1 │ │ dummy :: Identifier │ scope_layer=1 │ │ [call] │ │ │ deepcopy :: Identifier │ scope_layer=1 │ │ dummy :: Identifier │ scope_layer=1 │ │ [call] │ │ │ [curly] │ │ │ Dict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ Any :: Identifier │ scope_layer=1 │ │ [call] │ │ │ Base.Docs.doc! :: Value │ macro_source=273 │ │ SummarizedExperiments :: Value │ macro_source=273 │ │ [call] │ │ │ Base.Docs.Binding :: Value │ macro_source=273 │ │ SummarizedExperiments :: Value │ macro_source=273 │ │ [inert] │ │ │ SummarizedExperiment :: Identifier │ │ │ [call] │ macro_source=273 │ │ Base.Docs.docstr :: Value │ macro_source=273 │ │ [call] │ macro_source=273 │ │ Core.svec :: Value │ macro_source=273 │ │ " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ macro_source=273 │ │ [call] │ macro_source=273 │ │ Dict{Symbol, Any} :: Value │ macro_source=273 │ │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ │ :linenumber => 47 :: Value │ macro_source=273 │ │ :module => SummarizedExperiments :: Value │ macro_source=273 │ │ [curly] │ │ │ Union :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ Tuple :: Identifier │ scope_layer=1 │ │ #1#val :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [=] │ │ │ #2#val :: Identifier │ scope_layer=1 │ │ [function] │ │ │ [call] │ │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ │ [::] │ │ │ assays :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ OrderedDict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ AbstractArray :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [if] │ │ │ [call] │ │ │ < :: Identifier │ scope_layer=1 │ │ [call] │ │ │ length :: Identifier │ scope_layer=1 │ │ assays :: Identifier │ scope_layer=1 │ │ 1 :: Value │ macro_source=273 │ │ [block] │ │ │ [call] │ │ │ throw :: Identifier │ scope_layer=1 │ │ [call] │ │ │ ErrorException :: Identifier │ scope_layer=1 │ │ "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied" :: Value │ macro_source=273 │ │ [=] │ │ │ refdims :: Identifier │ scope_layer=1 │ │ [call] │ │ │ size :: Identifier │ scope_layer=1 │ │ [.] │ │ │ [call] │ │ │ first :: Identifier │ scope_layer=1 │ │ assays :: Identifier │ scope_layer=1 │ │ [inert] │ │ │ second :: Identifier │ │ │ [if] │ │ │ [call] │ │ │ < :: Identifier │ scope_layer=1 │ │ [call] │ │ │ length :: Identifier │ scope_layer=1 │ │ refdims :: Identifier │ scope_layer=1 │ │ 2 :: Value │ macro_source=273 │ │ [block] │ │ │ [call] │ │ │ throw :: Identifier │ scope_layer=1 │ │ [call] │ │ │ DimensionMismatch :: Identifier │ scope_layer=1 │ │ "'assays' should contain arrays with 2 or more dimensions" :: Value │ macro_source=273 │ │ [=] │ │ │ first_name :: Identifier │ scope_layer=1 │ │ [.] │ │ │ [call] │ │ │ first :: Identifier │ scope_layer=1 │ │ assays :: Identifier │ scope_layer=1 │ │ [inert] │ │ │ first :: Identifier │ │ │ [for] │ │ │ [=] │ │ │ [tuple] │ │ │ key :: Identifier │ scope_layer=1 │ │ val :: Identifier │ scope_layer=1 │ │ assays :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [if] │ │ │ [call] │ │ │ ! :: Identifier │ scope_layer=1 │ │ [call] │ │ │ check_assay_dimensions :: Identifier │ scope_layer=1 │ │ [call] │ │ │ size :: Identifier │ scope_layer=1 │ │ val :: Identifier │ scope_layer=1 │ │ refdims :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [call] │ │ │ throw :: Identifier │ scope_layer=1 │ │ [call] │ │ │ DimensionMismatch :: Identifier │ scope_layer=1 │ │ [call] │ │ │ * :: Identifier │ scope_layer=1 │ │ "'assays[" :: Value │ macro_source=273 │ │ [call] │ │ │ repr :: Identifier │ scope_layer=1 │ │ key :: Identifier │ scope_layer=1 │ │ "]' and 'assays[" :: Value │ macro_source=273 │ │ [call] │ │ │ repr :: Identifier │ scope_layer=1 │ │ first_name :: Identifier │ scope_layer=1 │ │ "]' should have the same extents for the first 2 dimensions" :: Value │ macro_source=273 │ │ [=] │ │ │ rowdata :: Identifier │ scope_layer=1 │ │ [call] │ │ │ DataFrame :: Identifier │ scope_layer=1 │ │ [kw] │ │ │ name :: Identifier │ scope_layer=1 │ │ [call] │ │ │ [curly] │ │ │ Vector :: Identifier │ scope_layer=1 │ │ Nothing :: Identifier │ scope_layer=1 │ │ undef :: Identifier │ scope_layer=1 │ │ [ref] │ │ │ refdims :: Identifier │ scope_layer=1 │ │ 1 :: Value │ macro_source=273 │ │ [=] │ │ │ coldata :: Identifier │ scope_layer=1 │ │ [call] │ │ │ DataFrame :: Identifier │ scope_layer=1 │ │ [kw] │ │ │ name :: Identifier │ scope_layer=1 │ │ [call] │ │ │ [curly] │ │ │ Vector :: Identifier │ scope_layer=1 │ │ Nothing :: Identifier │ scope_layer=1 │ │ undef :: Identifier │ scope_layer=1 │ │ [ref] │ │ │ refdims :: Identifier │ scope_layer=1 │ │ 2 :: Value │ macro_source=273 │ │ [call] │ │ │ new :: Identifier │ scope_layer=1 │ │ assays :: Identifier │ scope_layer=1 │ │ rowdata :: Identifier │ scope_layer=1 │ │ coldata :: Identifier │ scope_layer=1 │ │ [call] │ │ │ [curly] │ │ │ Dict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ Any :: Identifier │ scope_layer=1 │ │ [call] │ │ │ Base.Docs.doc! :: Value │ macro_source=273 │ │ SummarizedExperiments :: Value │ macro_source=273 │ │ [call] │ │ │ Base.Docs.Binding :: Value │ macro_source=273 │ │ SummarizedExperiments :: Value │ macro_source=273 │ │ [inert] │ │ │ SummarizedExperiment :: Identifier │ │ │ [call] │ macro_source=273 │ │ Base.Docs.docstr :: Value │ macro_source=273 │ │ [call] │ macro_source=273 │ │ Core.svec :: Value │ macro_source=273 │ │ " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" :: Value │ macro_source=273 │ │ [call] │ macro_source=273 │ │ Dict{Symbol, Any} :: Value │ macro_source=273 │ │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ │ :linenumber => 76 :: Value │ macro_source=273 │ │ :module => SummarizedExperiments :: Value │ macro_source=273 │ │ [curly] │ │ │ Union :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ Tuple :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ OrderedDict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ AbstractArray :: Identifier │ scope_layer=1 │ │ #2#val :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [=] │ │ │ #3#val :: Identifier │ scope_layer=1 │ │ [function] │ │ │ [call] │ │ │ SummarizedExperiment :: Identifier │ scope_layer=1 │ │ [::] │ │ │ assays :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ OrderedDict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ AbstractArray :: Identifier │ scope_layer=1 │ │ [::] │ │ │ rowdata :: Identifier │ scope_layer=1 │ │ DataFrame :: Identifier │ scope_layer=1 │ │ [::] │ │ │ coldata :: Identifier │ scope_layer=1 │ │ DataFrame :: Identifier │ scope_layer=1 │ │ [kw] │ │ │ [::] │ │ │ metadata :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ Dict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ Any :: Identifier │ scope_layer=1 │ │ [call] │ │ │ [curly] │ │ │ Dict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ Any :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [=] │ │ │ refdims :: Identifier │ scope_layer=1 │ │ [tuple] │ │ │ [ref] │ │ │ [call] │ │ │ size :: Identifier │ scope_layer=1 │ │ rowdata :: Identifier │ scope_layer=1 │ │ 1 :: Value │ macro_source=273 │ │ [ref] │ │ │ [call] │ │ │ size :: Identifier │ scope_layer=1 │ │ coldata :: Identifier │ scope_layer=1 │ │ 1 :: Value │ macro_source=273 │ │ [for] │ │ │ [=] │ │ │ [tuple] │ │ │ key :: Identifier │ scope_layer=1 │ │ val :: Identifier │ scope_layer=1 │ │ assays :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [if] │ │ │ [call] │ │ │ ! :: Identifier │ scope_layer=1 │ │ [call] │ │ │ check_assay_dimensions :: Identifier │ scope_layer=1 │ │ [call] │ │ │ size :: Identifier │ scope_layer=1 │ │ val :: Identifier │ scope_layer=1 │ │ refdims :: Identifier │ scope_layer=1 │ │ [block] │ │ │ [call] │ │ │ throw :: Identifier │ scope_layer=1 │ │ [call] │ │ │ DimensionMismatch :: Identifier │ scope_layer=1 │ │ [call] │ │ │ * :: Identifier │ scope_layer=1 │ │ "dimensions of 'assays[" :: Value │ macro_source=273 │ │ [call] │ │ │ repr :: Identifier │ scope_layer=1 │ │ key :: Identifier │ scope_layer=1 │ │ "]' are not consistent with 'rowdata' or 'coldata'" :: Value │ macro_source=273 │ │ [call] │ │ │ check_dataframe_in_constructor :: Identifier │ scope_layer=1 │ │ rowdata :: Identifier │ scope_layer=1 │ │ "rowdata" :: Value │ macro_source=273 │ │ [call] │ │ │ check_dataframe_in_constructor :: Identifier │ scope_layer=1 │ │ coldata :: Identifier │ scope_layer=1 │ │ "coldata" :: Value │ macro_source=273 │ │ [call] │ │ │ new :: Identifier │ scope_layer=1 │ │ assays :: Identifier │ scope_layer=1 │ │ rowdata :: Identifier │ scope_layer=1 │ │ coldata :: Identifier │ scope_layer=1 │ │ metadata :: Identifier │ scope_layer=1 │ │ [call] │ │ │ Base.Docs.doc! :: Value │ macro_source=273 │ │ SummarizedExperiments :: Value │ macro_source=273 │ │ [call] │ │ │ Base.Docs.Binding :: Value │ macro_source=273 │ │ SummarizedExperiments :: Value │ macro_source=273 │ │ [inert] │ │ │ SummarizedExperiment :: Identifier │ │ │ [call] │ macro_source=273 │ │ Base.Docs.docstr :: Value │ macro_source=273 │ │ [call] │ macro_source=273 │ │ Core.svec :: Value │ macro_source=273 │ │ " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" :: Value │ macro_source=273 │ │ [call] │ macro_source=273 │ │ Dict{Symbol, Any} :: Value │ macro_source=273 │ │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ │ :linenumber => 129 :: Value │ macro_source=273 │ │ :module => SummarizedExperiments :: Value │ macro_source=273 │ │ [curly] │ │ │ Union :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ Tuple :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ OrderedDict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ AbstractArray :: Identifier │ scope_layer=1 │ │ DataFrame :: Identifier │ scope_layer=1 │ │ DataFrame :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ Tuple :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ OrderedDict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ AbstractArray :: Identifier │ scope_layer=1 │ │ DataFrame :: Identifier │ scope_layer=1 │ │ DataFrame :: Identifier │ scope_layer=1 │ │ [curly] │ │ │ Dict :: Identifier │ scope_layer=1 │ │ String :: Identifier │ scope_layer=1 │ │ Any :: Identifier │ scope_layer=1 │ │ #3#val :: Identifier │ scope_layer=1 │ │ [call] │ │ │ Base.Docs.doc! :: Value │ macro_source=273 │ │ SummarizedExperiments :: Value │ macro_source=273 │ │ [call] │ │ │ Base.Docs.Binding :: Value │ macro_source=273 │ │ SummarizedExperiments :: Value │ │ │ [inert] │ jl_source=L65 │ │ SummarizedExperiment :: Identifier │ │ │ [call] │ │ │ Base.Docs.docstr :: Value │ macro_source=273 │ │ [call] │ macro_source=273 │ │ Core.svec :: Value │ macro_source=273 │ │ "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" :: Value │ macro_source=273 │ │ [call] │ │ │ Dict{Symbol, Any} :: Value │ macro_source=273 │ │ :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :: Value │ macro_source=273 │ │ :linenumber => 24 :: Value │ macro_source=273 │ │ :module => SummarizedExperiments :: Value │ macro_source=273 │ │ [call] │ │ │ Pair :: Value │ macro_source=273 │ │ [inert] │ │ │ fields :: Identifier │ │ │ [call] │ macro_source=273 │ │ Dict{Symbol, Any} :: Value │ macro_source=273 │ │ [curly] │ │ │ Union :: Identifier │ scope_layer=1 │ │ val :: Identifier │ scope_layer=3 │ │ │ │ file = "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" │ │ line = 24 │ └ mod = SummarizedExperiments │ ERROR: LoadError: LoweringError: │ #= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =# - assignment syntax in structure fields is reserved │ Expression: │ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) │ Containing expressions: │ (block (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (:: metadata (curly Dict String Any)) (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) (call Base.Docs.doc! SummarizedExperiments (call Base.Docs.Binding SummarizedExperiments :SummarizedExperiment) (call Base.Docs.docstr (call Core.svec " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :linenumber => 47 :module => SummarizedExperiments)) (curly Union (curly Tuple))) #1#val (= #2#val (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray))) (block (if (call < (call length assays) 1) (block (call throw (call ErrorException "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied")))) (= refdims (call size (. (call first assays) :second))) (if (call < (call length refdims) 2) (block (call throw (call DimensionMismatch "'assays' should contain arrays with 2 or more dimensions")))) (= first_name (. (call first assays) :first)) (for (iteration (in (tuple key val) assays)) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "'assays[" (call repr key) "]' and 'assays[" (call repr first_name) "]' should have the same extents for the first 2 dimensions"))))))) (= rowdata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 1))))) (= coldata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 2))))) (call new assays rowdata coldata (call (curly Dict String Any)))))) (call Base.Docs.doc! SummarizedExperiments (call Base.Docs.Binding SummarizedExperiments :SummarizedExperiment) (call Base.Docs.docstr (call Core.svec " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :linenumber => 76 :module => SummarizedExperiments)) (curly Union (curly Tuple (curly OrderedDict String AbstractArray)))) #2#val (= #3#val (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (kw (:: metadata (curly Dict String Any)) (call (curly Dict String Any)))) (block (= refdims (tuple (ref (call size rowdata) 1) (ref (call size coldata) 1))) (for (iteration (in (tuple key val) assays)) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "dimensions of 'assays[" (call repr key) "]' are not consistent with 'rowdata' or 'coldata'"))))))) (call check_dataframe_in_constructor rowdata "rowdata") (call check_dataframe_in_constructor coldata "coldata") (call new assays rowdata coldata metadata)))) (call Base.Docs.doc! SummarizedExperiments (call Base.Docs.Binding SummarizedExperiments :SummarizedExperiment) (call Base.Docs.docstr (call Core.svec " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl" :linenumber => 129 :module => SummarizedExperiments)) (curly Union (curly Tuple (curly OrderedDict String AbstractArray) DataFrame DataFrame) (curly Tuple (curly OrderedDict String AbstractArray) DataFrame DataFrame (curly Dict String Any)))) #3#val) │ │ Detailed provenance: │ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) │ └─ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) │ └─ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) │ └─ (= #1#val (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) │ ├─ @ /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 │ └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 =#) "The `SummarizedExperiment` class is a Bioconductor container for matrix-like data with annotations on the rows and columns.\nIt is the data structure underlying analysis workflows for many genomics data modalities,\nranging from microarrays, bulk and single-cell RNA sequencing, ChIP-seq, epigenomics and beyond.\n\nAny number of arrays (also known as \"assays\") can be stored in the container, \nprovided they are assigned to unique names and all have the same extents for the first two dimensions.\nThis reflects the fact that we often have multiple experimental readouts of the same shape, e.g., raw counts, normalized values, quality metrics.\nThese assays are held as an `OrderedDict` so the order of their addition is respected.\n\nThe row and column annotations are stored as `DataFrame`s, with number of rows equal to the number of assay rows and columns, respectively.\nAny number and type of columns may be present in each `DataFrame`,\nwith the only constraint being that the first column must be a `\"name\"` column of strings containing the feature/sample names.\nIf no names are present, the `\"name\"` column must contain `nothing`s.\n\nEach instance may also contain arbitrary metadata not associated with the rows or columns.\n" (struct true SummarizedExperiment (block (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (:: metadata (curly Dict String Any)) (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:47 =#) " SummarizedExperiment()\n\nCreate an empty `SummarizedExperiment` with no assays and empty row/column annotations.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> SummarizedExperiment()\n0x0 SummarizedExperiment\n assays(0):\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" (function (call SummarizedExperiment) (block (= dummy (call DataFrame (kw name (ref String)))) (call new (call (curly OrderedDict String AbstractArray)) dummy (call deepcopy dummy) (call (curly Dict String Any)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:76 =#) " SummarizedExperiment(assays)\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n`assays` should contain at least one assay matrix.\n\nFor the `coldata` and `rowdata`, an empty `DataFrame` is created with a `\"name\"` column containing all `nothing`s.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> x = SummarizedExperiment(assays)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames:\n rowdata(1): name\n colnames:\n coldata(1): name\n metadata(0):\n```\n" (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray))) (block (if (call < (call length assays) 1) (block (call throw (call ErrorException "expected at least one array in 'assays' if 'rowdata' or 'coldata' are not supplied")))) (= refdims (call size (. (call first assays) (inert second)))) (if (call < (call length refdims) 2) (block (call throw (call DimensionMismatch "'assays' should contain arrays with 2 or more dimensions")))) (= first_name (. (call first assays) (inert first))) (for (= (tuple key val) assays) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "'assays[" (call repr key) "]' and 'assays[" (call repr first_name) "]' should have the same extents for the first 2 dimensions"))))))) (= rowdata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 1))))) (= coldata (call DataFrame (kw name (call (curly Vector Nothing) undef (ref refdims 2))))) (call new assays rowdata coldata (call (curly Dict String Any)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:129 =#) " SummarizedExperiment(assays, rowdata, coldata, metadata = Dict{String,Any}())\n\nCreate an instance of a `SummarizedExperiment` with the supplied assays and the row/column annotations.\n\nAll entries of `assays` should have the same extents for the first two dimensions.\nHowever, they can otherwise have any number of other dimensions.\nEach assay can be of different type.\n\nFor `rowdata`, the number of rows must be equal to the extent of the first dimension for each entry in `assays`.\nSimilarly, for `coldata`, the number of rows must be equal to the extent of the second dimension.\nIn both cases, the first column must be called `\"name\"` and contain a `Vector` of `String`s or `Nothing`s (if no names are available).\n\n`assays` may also be empty.\n\n# Examples\n```jldoctest\njulia> using SummarizedExperiments\n\njulia> assays = OrderedDict{String, AbstractArray}(\n \"foobar\" => [[1,2] [3,4] [5,6]], \n \"whee\" => [[1.2,2.3] [3.4,4.5] [5.6,7.8]]);\n\njulia> rowdata = DataFrame(\n name = [ \"X\", \"Y\" ],\n type = [\"protein\", \"transcript\"]);\n\njulia> coldata = DataFrame(\n name = [ \"a\", \"b\", \"c\" ],\n treatment = [\"normal\", \"drug1\", \"drug2\"]);\n\njulia> x = SummarizedExperiment(assays, rowdata, coldata)\n2x3 SummarizedExperiment\n assays(2): foobar whee\n rownames: X Y\n rowdata(2): name type\n colnames: a b c\n coldata(2): name treatment\n metadata(0):\n```\n" (function (call SummarizedExperiment (:: assays (curly OrderedDict String AbstractArray)) (:: rowdata DataFrame) (:: coldata DataFrame) (kw (:: metadata (curly Dict String Any)) (call (curly Dict String Any)))) (block (= refdims (tuple (ref (call size rowdata) 1) (ref (call size coldata) 1))) (for (= (tuple key val) assays) (block (if (call ! (call check_assay_dimensions (call size val) refdims)) (block (call throw (call DimensionMismatch (call * "dimensions of 'assays[" (call repr key) "]' are not consistent with 'rowdata' or 'coldata'"))))))) (call check_dataframe_in_constructor rowdata "rowdata") (call check_dataframe_in_constructor coldata "coldata") (call new assays rowdata coldata metadata))))))) │ └─ @ /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 │ │ Stacktrace: │ [1] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}}) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3166 │ [2] expand_struct_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3736 │ [3] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4317 │ [4] expand_assignment(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, is_const::Bool) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:1320 │ [5] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4177 │ [6] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4133 [inlined] │ [7] (::Base.JuliaLowering.var"#expand_forms_2##2#expand_forms_2##3"{Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}})(e::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4421 [inlined] │ [8] mapchildren(f::Base.JuliaLowering.var"#expand_forms_2##2#expand_forms_2##3"{Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}}, ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}) │ @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:707 │ [9] getindex(A::Vector{UnitRange{Int64}}, i::Int64) │ @ Base essentials.jl:1040 [inlined] │ [10] numchildren(graph::Base.JuliaSyntax.SyntaxGraph{Dict{Symbol, Dict{Int64, Any}}}, id::Int64) │ @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:121 [inlined] │ [11] numchildren(ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}) │ @ Base.JuliaSyntax /source/usr/share/julia/JuliaSyntax/src/porcelain/syntax_graph.jl:306 [inlined] │ [12] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4268 │ [13] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4133 [inlined] │ [14] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4450 │ [15] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:30 │ [16] include(mapexpr::Function, mod::Module, _path::String) │ @ Base Base.jl:327 │ [17] top-level scope │ @ ~/.julia/packages/SummarizedExperiments/Nxbzn/src/SummarizedExperiments.jl:7 │ [18] include(mod::Module, _path::String) │ @ Base Base.jl:326 │ [19] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing) │ @ Base loading.jl:3296 │ [20] top-level scope │ @ stdin:5 │ [21] eval(m::Module, e::Any) │ @ Core boot.jl:521 │ [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String) │ @ Base loading.jl:3132 │ [23] include_string(m::Module, txt::String, fname::String) │ @ Base loading.jl:3142 [inlined] │ [24] exec_options(opts::Base.JLOptions) │ @ Base client.jl:353 │ [25] _start() │ @ Base client.jl:596 │ in expression starting at /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/class.jl:24 │ in expression starting at /home/pkgeval/.julia/packages/SummarizedExperiments/Nxbzn/src/SummarizedExperiments.jl:1 │ in expression starting at stdin:5 └ ERROR: The following 2 packages failed to precompile: MultiAssayExperiments Failed to precompile MultiAssayExperiments [c9137f73-29f3-4436-b9da-846274f1d332] to "/home/pkgeval/.julia/compiled/v1.14/MultiAssayExperiments/jl_W2Ym66" (ProcessExited(1)). SummarizedExperiments Failed to precompile SummarizedExperiments [b04b66ec-f619-4ebf-810e-cf5ccc546695] to "/home/pkgeval/.julia/compiled/v1.14/SummarizedExperiments/jl_dNrQq6" (ProcessExited(1)). Loading failed after 118.2s ERROR: LoadError: failed process: Process(`/opt/julia/bin/julia -C native -J/opt/julia/lib/julia/sys.so -g1 --check-bounds=yes --inline=yes --check-bounds=yes --pkgimages=existing -e 'using MultiAssayExperiments'`, ProcessExited(1)) [1] Stacktrace: [1] pipeline_error(proc::Base.Process) @ Base process.jl:612 [inlined] [2] run(::Cmd; wait::Bool) @ Base process.jl:525 [3] run(::Cmd) @ Base process.jl:522 [4] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:197 [5] include(mod::Module, _path::String) @ Base Base.jl:326 [6] exec_options(opts::Base.JLOptions) @ Base client.jl:355 [7] _start() @ Base client.jl:596 in expression starting at /PkgEval.jl/scripts/evaluate.jl:188 PkgEval failed after 2213.73s: package fails to precompile