| 
                        std.alternative
                     | 
                    
                        Implementation of the Alternative type
                     | 
                
            
                
                    | 
                        std.applicative
                     | 
                    
                        Implementation of the Applicative type
                     | 
                
            
                
                    | 
                        std.array
                     | 
                    
                        A dynamically sized contigous sequence.
                     | 
                
            
                
                    | 
                        std.assert
                     | 
                    
                        Assertion functions.
                     | 
                
            
                
                    | 
                        std.bool
                     | 
                    
                        The boolean type.
                     | 
                
            
                
                    | 
                        std.byte
                     | 
                    
                        An 8-bit unsigned integer.
                     | 
                
            
                
                    | 
                        std.category
                     | 
                    
                        Implementation of the Category type
                     | 
                
            
                
                    | 
                        std.channel
                     | 
                    
                        Mpmc channels.
                     | 
                
            
                
                    | 
                        std.char
                     | 
                    
                        A character type.
                     | 
                
            
                
                    | 
                        std.cmp
                     | 
                    
                        Functionality for ordering and comparison.
                     | 
                
            
                
                    | 
                        std.debug
                     | 
                    
                        Debug library.
                     | 
                
            
                
                    | 
                        std.disposable
                     | 
                    
                        A Disposable abstracts over different kinds of resources.
                     | 
                
            
                
                    | 
                        std.effect
                     | 
                    
                        Composable effect types
                     | 
                
            
                
                    | 
                        std.env
                     | 
                    
                        Inspection and manipulation of the process's environment.
                     | 
                
            
                
                    | 
                        std.float
                     | 
                    
                        The 64-bit floating point type.
                     | 
                
            
                
                    | 
                        std.foldable
                     | 
                    
                        Implementation of the Foldable type
                     | 
                
            
                
                    | 
                        std.fs
                     | 
                    
                        Functions for working with the file system
                     | 
                
            
                
                    | 
                        std.function
                     | 
                    
                        Conveniences for working with functions.
                     | 
                
            
                
                    | 
                        std.functor
                     | 
                    
                        Implementation of the Functor type
                     | 
                
            
                
                    | 
                        std.group
                     | 
                    
                        Implementation of the Group type
                     | 
                
            
                
                    | 
                        std.http
                     | 
                    
                        A minimal library for writing HTTP servers.
                     | 
                
            
                
                    | 
                        std.identity
                     | 
                    
                        The identity functor and monad.
                     | 
                
            
                
                    | 
                        std.int
                     | 
                    
                        The signed 64-bit integer type.
                     | 
                
            
                
                    | 
                        std.io
                     | 
                    
                        Functions for working with I/O
                     | 
                
            
                
                    | 
                        std.json
                     | 
                    
                        A type representing a JSON value.
                     | 
                
            
                
                    | 
                        std.lazy
                     | 
                    
                        Lazy values.
                     | 
                
            
                
                    | 
                        std.lazyt
                     | 
                    
                        Monad transformer version of Lazy
                     | 
                
            
                
                    | 
                        std.list
                     | 
                    
                        A linked list type.
                     | 
                
            
                
                    | 
                        std.map
                     | 
                    
                        An ordered map list type
                     | 
                
            
                
                    | 
                        std.monad
                     | 
                    
                        Implementation of the Monad type
                     | 
                
            
                
                    | 
                        std.monoid
                     | 
                    
                        Implementation of the Monoid type
                     | 
                
            
                
                    | 
                        std.num
                     | 
                    
                        Operations on numbers.
                     | 
                
            
                
                    | 
                        std.option
                     | 
                    
                        A type that can represent the abscence of a value
                     | 
                
            
                
                    | 
                        std.parser
                     | 
                    
                        A simple parser combinator library.
                     | 
                
            
                
                    | 
                        std.path
                     | 
                    
                        Functions operating on paths
                     | 
                
            
                
                    | 
                        std.prelude
                     | 
                    
                        Definitions which gets implicit re-export in every file.
                     | 
                
            
                
                    | 
                        std.process
                     | 
                    
                        Functions for working with external processes
                     | 
                
            
                
                    | 
                        std.random
                     | 
                    
                        Basic random number generation
                     | 
                
            
                
                    | 
                        std.reference
                     | 
                    
                        A mutable reference type
                     | 
                
            
                
                    | 
                        std.regex
                     | 
                    
                        Bindings for rust-lang/regex
                     | 
                
            
                
                    | 
                        std.result
                     | 
                    
                        Error handling type.
                     | 
                
            
                
                    | 
                        std.semigroup
                     | 
                    
                        Implementation of the Applicative type
                     | 
                
            
                
                    | 
                        std.show
                     | 
                    
                        Value to string conversion.
                     | 
                
            
                
                    | 
                        std.state
                     | 
                    
                        The state monad.
                     | 
                
            
                
                    | 
                        std.statet
                     | 
                    
                        The state monad transformer.
                     | 
                
            
                
                    | 
                        std.stream
                     | 
                    
                        Lazy stream type.
                     | 
                
            
                
                    | 
                        std.string
                     | 
                    
                        A UTF-8 encoded string
                     | 
                
            
                
                    | 
                        std.test
                     | 
                    
                        A simple test library.
                     | 
                
            
                
                    | 
                        std.thread
                     | 
                    
                        Green threading library.
                     | 
                
            
                
                    | 
                        std.transformer
                     | 
                    
                        Utilities for writing Monad transformers
                     | 
                
            
                
                    | 
                        std.traversable
                     | 
                    
                        Implementation of the Traversable type
                     | 
                
            
                
                    | 
                        std.types
                     | 
                    
                        Definition of standard types separate from the prelude to allow primitives to use them
                     | 
                
            
                
                    | 
                        std.unit
                     | 
                    
                        The unit type.
                     | 
                
            
                
                    | 
                        std.writer
                     | 
                    
                        Implementation of the Writer type
                     |