| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Unison.Runtime.Stack
Contents
Synopsis
- data K
- data GClosure comb
- = GList !(Deque Val)
- | GText !Text
- | GEnum !PackedTag
- | GData1 !PackedTag !Val
- | GData2 !PackedTag !Val !Val
- | GData5 !PackedTag !Val !Val !Val !Val !Val
- | GData3 !PackedTag !Val !Val !Val
- | GData4 !PackedTag !Val !Val !Val !Val
- | GData6 !PackedTag !Val !Val !Val !Val !Val !Val
- | GDataG !PackedTag !USeg !BSeg
- | GBytes !Bytes
- | GPAp !CombIx !(GCombInfo comb) !USeg !BSeg
- | GCaptured !K !Int !USeg !BSeg
- | GRecord !RecordShape !RecordVals
- | GForeign !Foreign
- | GUnboxedTypeTag !UnboxedTypeTag
- | GAffine !(EnumSet Word64) !AEnv !AffineRef
- | GBlackHole
- newtype Closure where
- Closure { }
- pattern DataC :: PackedTag -> SegList -> Closure
- pattern RecordC :: RecordShape -> RecordVals -> Closure
- pattern PApV :: CombIx -> RCombInfo Val -> SegList -> Closure
- pattern CapV :: K -> Int -> SegList -> Closure
- pattern PAp :: CombIx -> GCombInfo (RComb Val) -> Seg -> Closure
- pattern Enum :: PackedTag -> Closure
- pattern Data1 :: PackedTag -> Val -> Closure
- pattern Data2 :: PackedTag -> Val -> Val -> Closure
- pattern Data3 :: PackedTag -> Val -> Val -> Val -> Closure
- pattern Data4 :: PackedTag -> Val -> Val -> Val -> Val -> Closure
- pattern Data5 :: PackedTag -> Val -> Val -> Val -> Val -> Val -> Closure
- pattern Data6 :: PackedTag -> Val -> Val -> Val -> Val -> Val -> Val -> Closure
- pattern DataG :: PackedTag -> Seg -> Closure
- pattern RecordG :: RecordShape -> RecordVals -> Closure
- pattern Captured :: K -> Int -> Seg -> Closure
- pattern TextC :: Text -> Closure
- pattern ListC :: Deque Val -> Closure
- pattern BytesC :: Bytes -> Closure
- pattern Foreign :: Foreign -> Closure
- pattern Affine :: EnumSet Word64 -> AEnv -> AffineRef -> Closure
- pattern BlackHole :: Closure
- pattern UnboxedTypeTag :: UnboxedTypeTag -> Closure
- data Failure a = Failure Reference Text a
- data Foreign
- = WrapMap !(Map Val Val)
- | WrapArray !(Array Val)
- | WrapNatural !Natural
- | WrapByteArray !ByteArray
- | WrapCDynFunc !CDynFunc
- | WrapCPattern !CPattern
- | WrapCharPattern !CharPattern
- | WrapCode !(Referenced Code)
- | WrapClientSockAddr !ClientSockAddr
- | WrapDLL !DLL
- | WrapFFISpec !FFSpec
- | WrapFFIType !FFType
- | WrapHandle !Handle
- | WrapHashAlgorithm !HashAlgorithm
- | WrapIORef !(IORef Val)
- | WrapInteger !Integer
- | WrapListenSocket !ListenSocket
- | WrapMutableByteArray !(MutableByteArray RealWorld)
- | WrapMutableArray !(MutableArray RealWorld Val)
- | WrapMVar !(MVar Val)
- | WrapProcessHandle !ProcessHandle
- | WrapPromise !(Promise Val)
- | WrapPtr !(Ptr ())
- | WrapForeignPtr !(ForeignPtr ())
- | WrapReference !Reference
- | WrapReferent !Referent
- | WrapSocket !Socket
- | WrapThreadId !ThreadId
- | WrapTicket !(Ticket Val)
- | WrapTimeSpec !TimeSpec
- | WrapTlsClientParams !ClientParams
- | WrapTlsServerParams !ServerParams
- | WrapTls !Tls
- | WrapTVar !(TVar Val)
- | WrapUDPSocket !UDPSocket
- | WrapValue !(Referenced Value)
- | WrapX509PrivKey !PrivKey
- | WrapX509SignedCertificate !SignedCertificate
- | WrapSignal !Signal
- | WrapSignalSubscription !Subscription
- foreignRef :: Foreign -> Reference
- foreignName :: Foreign -> String
- class BuiltinForeign f where
- builtinName :: Tagged f String
- wrapBuiltin :: f -> Closure
- maybeUnwrapBuiltin :: Closure -> Maybe f
- newtype AffineRef = ARef (IORef Closure)
- type AEnv = EnumMap Word64 AffineRef
- type DEnv = EnumMap Word64 Val
- emptyDEnv :: DEnv
- emptyAEnv :: AEnv
- data HEnv = HEnv {}
- closureTag :: Closure -> PackedTag
- dataTag :: Closure -> Maybe PackedTag
- formDataReplaced :: PackedTag -> Seg -> Closure
- mapFamily :: ReplacementUse
- mapReplaced :: Bool
- unitClosure :: Closure
- data UnboxedTypeTag
- unboxedTypeTagToInt :: UnboxedTypeTag -> Int
- unboxedTypeTagFromInt :: HasCallStack => Int -> UnboxedTypeTag
- witnessTag :: Int -> Closure
- type IxClosure = GClosure CombIx
- newtype Callback = Hook (XStack -> IO ())
- data Augment
- data Dump
- data Stack = Stack {}
- type XStack = (# Int#, Int#, Int#, MutableByteArray# (PrimState IO), MutableArray# (PrimState IO) Closure #)
- pattern XStack :: Int# -> Int# -> Int# -> MutableByteArray# RealWorld -> MutableArray# RealWorld Closure -> Stack
- packXStack :: XStack -> Stack
- unpackXStack :: Stack -> XStack
- xStackIOToIO :: IOXStack -> IO Stack
- stackIOToIOX :: IO Stack -> IOXStack
- estackIOToIOX :: IO (Bool, Stack) -> IOEXStack
- exStackIOToIO :: IOEXStack -> IO (Bool, Stack)
- type IOXStack = State# RealWorld -> (# State# RealWorld, XStack #)
- type IOEXStack = State# RealWorld -> (# State# RealWorld, Bool, XStack #)
- apX :: Stack -> Int#
- fpX :: Stack -> Int#
- spX :: Stack -> Int#
- ustkX :: Stack -> MutableByteArray# RealWorld
- bstkX :: Stack -> MutableArray# RealWorld Closure
- type Off = Int
- type SZ = Int
- type FP = Int
- type Seg = (USeg, BSeg)
- type USeg = ByteArray
- type BSeg = Array Closure
- type SegList = [Val]
- type RecordVals = Vector Val
- recordVals :: Seg -> RecordVals
- segToList :: Seg -> SegList
- data Val where
- emptyVal :: Val
- falseVal :: Val
- trueVal :: Val
- boxedVal :: BVal -> Val
- type USeq = Deque Val
- traceK :: Reference -> K -> [(Reference, Int)]
- frameDataSize :: K -> Int
- data RuntimePanic = Panic String (Maybe Val)
- marshalUnwrapForeignIO :: (HasCallStack, BuiltinForeign a) => Closure -> IO a
- unull :: USeg
- bnull :: BSeg
- nullSeg :: Seg
- peekD :: Stack -> IO Double
- peekOffD :: Stack -> Int -> IO Double
- peekC :: Stack -> IO Char
- peekOffC :: Stack -> Int -> IO Char
- poke :: DebugCallStack => Stack -> Val -> IO ()
- pokeD :: Stack -> Double -> IO ()
- pokeOffD :: Stack -> Int -> Double -> IO ()
- pokeC :: Stack -> Char -> IO ()
- pokeOffC :: Stack -> Int -> Char -> IO ()
- pokeBool :: DebugCallStack => Stack -> Bool -> IO ()
- pokeTag :: DebugCallStack => Stack -> Int -> IO ()
- peekTag :: DebugCallStack => Stack -> IO Int
- peekTagOff :: DebugCallStack => Stack -> Off -> IO Int
- peekI :: DebugCallStack => Stack -> IO Int
- peekOffI :: DebugCallStack => Stack -> Off -> IO Int
- peekN :: Stack -> IO Word64
- peekOffN :: Stack -> Int -> IO Word64
- pokeN :: Stack -> Word64 -> IO ()
- pokeOffN :: Stack -> Int -> Word64 -> IO ()
- pokeI :: Stack -> Int -> IO ()
- pokeOffI :: Stack -> Int -> Int -> IO ()
- pokeByte :: Stack -> Word8 -> IO ()
- peekBi :: BuiltinForeign b => Stack -> IO b
- peekOffBi :: BuiltinForeign b => Stack -> Int -> IO b
- pokeBi :: BuiltinForeign b => Stack -> b -> IO ()
- pokeOffBi :: BuiltinForeign b => Stack -> Int -> b -> IO ()
- peekBool :: Stack -> IO Bool
- peekOffBool :: Stack -> Int -> IO Bool
- peekOffS :: Stack -> Int -> IO USeq
- pokeS :: Stack -> USeq -> IO ()
- pokeOffS :: Stack -> Int -> USeq -> IO ()
- frameView :: Stack -> IO ()
- scount :: Seg -> Int
- closureTermRefs :: Monoid m => (Reference -> m) -> Closure -> m
- dumpAP :: Int -> Int -> Int -> Dump -> Int
- dumpFP :: Int -> Int -> Dump -> Int
- alloc :: Int -> IO Stack
- defaultStackSlots :: Int
- type MCombs = RCombs Val
- type MSection = RSection Val
- type MBranch = RBranch Val
- type MInstr = RInstr Val
- type MComb = RComb Val
- type MRef = RRef Val
- nativeOutWords :: Int
- nativeOutPtrs :: Int
- bstkSlots :: MutableArray RealWorld Closure -> Int
- peek :: DebugCallStack => Stack -> IO Val
- upeek :: DebugCallStack => Stack -> IO UVal
- bpeek :: DebugCallStack => Stack -> IO BVal
- peekOff :: DebugCallStack => Stack -> Off -> IO Val
- upeekOff :: DebugCallStack => Stack -> Off -> IO UVal
- bpeekOff :: DebugCallStack => Stack -> Off -> IO BVal
- bpoke :: DebugCallStack => Stack -> BVal -> IO ()
- bpokeOff :: DebugCallStack => Stack -> Off -> BVal -> IO ()
- pokeOff :: DebugCallStack => Stack -> Off -> Val -> IO ()
- upokeT :: DebugCallStack => Stack -> UVal -> BVal -> IO ()
- upokeOffT :: DebugCallStack => Stack -> Off -> UVal -> BVal -> IO ()
- unsafePokeIasN :: DebugCallStack => Stack -> Int -> IO ()
- bump :: Stack -> IO Stack
- bumpn :: Stack -> SZ -> IO Stack
- grabSeg :: Stack -> SZ -> IO (Seg, Stack)
- truncateSeg :: Stack -> SZ -> IO Stack
- ensure :: Stack -> SZ -> IO Stack
- ensureGenerously :: Stack -> SZ -> IO Stack
- duplicate :: Stack -> IO Stack
- discardFrame :: Stack -> IO Stack
- saveFrame :: Stack -> IO (Stack, SZ, SZ)
- saveArgs :: Stack -> IO (Stack, SZ)
- restoreFrame :: Stack -> SZ -> SZ -> IO Stack
- prepareArgs :: Stack -> Args' -> IO Stack
- acceptArgs :: Stack -> Int -> IO Stack
- frameArgs :: Stack -> IO Stack
- augSeg :: Augment -> Stack -> Seg -> Maybe Args' -> IO Seg
- dumpSeg :: Stack -> Seg -> Dump -> IO Stack
- adjustArgs :: Stack -> SZ -> IO Stack
- fsize :: Stack -> SZ
- asize :: Stack -> SZ
- useg :: [Int] -> USeg
- bseg :: [Closure] -> BSeg
- segFromList :: SegList -> Seg
- traverseListToSeg :: (a -> IO Val) -> [a] -> IO Seg
- traverseAccumSegToList :: (Val -> StateT s IO a) -> Seg -> StateT s IO [a]
- natTypeTag :: Closure
- intTypeTag :: Closure
- charTypeTag :: Closure
- floatTypeTag :: Closure
- hasNoAllocations :: Name -> Obligation
- inflateMap :: Map Val Val -> Closure
- deflateMap :: Closure -> Maybe (Map Val Val)
- data HashAlgorithm where
- HashAlgorithm :: forall a. HashAlgorithm a => Reference -> a -> HashAlgorithm
- data Tls = Tls {}
Documentation
Constructors
| GList !(Deque Val) | |
| GText !Text | |
| GEnum !PackedTag | |
| GData1 !PackedTag !Val | |
| GData2 !PackedTag !Val !Val | |
| GData5 !PackedTag !Val !Val !Val !Val !Val | |
| GData3 !PackedTag !Val !Val !Val | |
| GData4 !PackedTag !Val !Val !Val !Val | |
| GData6 !PackedTag !Val !Val !Val !Val !Val !Val | |
| GDataG !PackedTag !USeg !BSeg | seven or more fields |
| GBytes !Bytes | |
| GPAp | |
| GCaptured | |
| GRecord !RecordShape !RecordVals | |
| GForeign !Foreign | |
| GUnboxedTypeTag !UnboxedTypeTag | The type tag for the value in the corresponding unboxed stack slot. We should consider adding separate constructors for common builtin type tags. GHC will optimize nullary constructors into singletons. |
| GAffine | |
| GBlackHole | |
Instances
| Functor GClosure Source # | |
| Foldable GClosure Source # | |
Defined in Unison.Runtime.Stack Methods fold :: Monoid m => GClosure m -> m # foldMap :: Monoid m => (a -> m) -> GClosure a -> m # foldMap' :: Monoid m => (a -> m) -> GClosure a -> m # foldr :: (a -> b -> b) -> b -> GClosure a -> b # foldr' :: (a -> b -> b) -> b -> GClosure a -> b # foldl :: (b -> a -> b) -> b -> GClosure a -> b # foldl' :: (b -> a -> b) -> b -> GClosure a -> b # foldr1 :: (a -> a -> a) -> GClosure a -> a # foldl1 :: (a -> a -> a) -> GClosure a -> a # elem :: Eq a => a -> GClosure a -> Bool # maximum :: Ord a => GClosure a -> a # minimum :: Ord a => GClosure a -> a # | |
| Traversable GClosure Source # | |
| Show comb => Show (GClosure comb) Source # | |
Bundled Patterns
| pattern DataC :: PackedTag -> SegList -> Closure | |
| pattern RecordC :: RecordShape -> RecordVals -> Closure | |
| pattern PApV :: CombIx -> RCombInfo Val -> SegList -> Closure | |
| pattern CapV :: K -> Int -> SegList -> Closure | |
| pattern PAp :: CombIx -> GCombInfo (RComb Val) -> Seg -> Closure | |
| pattern Enum :: PackedTag -> Closure | |
| pattern Data1 :: PackedTag -> Val -> Closure | |
| pattern Data2 :: PackedTag -> Val -> Val -> Closure | |
| pattern Data3 :: PackedTag -> Val -> Val -> Val -> Closure | |
| pattern Data4 :: PackedTag -> Val -> Val -> Val -> Val -> Closure | |
| pattern Data5 :: PackedTag -> Val -> Val -> Val -> Val -> Val -> Closure | |
| pattern Data6 :: PackedTag -> Val -> Val -> Val -> Val -> Val -> Val -> Closure | |
| pattern DataG :: PackedTag -> Seg -> Closure | A constructor with seven or more fields (fewer go to the fixed-arity
constructors; |
| pattern RecordG :: RecordShape -> RecordVals -> Closure | |
| pattern Captured :: K -> Int -> Seg -> Closure | |
| pattern TextC :: Text -> Closure | A text: the runtime's one representation of a |
| pattern ListC :: Deque Val -> Closure | A list: the runtime's one representation of a |
| pattern BytesC :: Bytes -> Closure | A bytes value: the runtime's one representation of a |
| pattern Foreign :: Foreign -> Closure | |
| pattern Affine :: EnumSet Word64 -> AEnv -> AffineRef -> Closure | |
| pattern BlackHole :: Closure | |
| pattern UnboxedTypeTag :: UnboxedTypeTag -> Closure |
Instances
| ForeignConvention a => ForeignConvention (Failure a) Source # | |
Constructors
foreignRef :: Foreign -> Reference Source #
foreignName :: Foreign -> String Source #
class BuiltinForeign f where Source #
The closure holding a Haskell value: Foreign (Wrap... x) for most,
a TextC or ListC for a text or a list.
Methods
builtinName :: Tagged f String Source #
wrapBuiltin :: f -> Closure Source #
maybeUnwrapBuiltin :: Closure -> Maybe f Source #
Instances
closureTag :: Closure -> PackedTag Source #
dataTag :: Closure -> Maybe PackedTag Source #
The packed tag of a data constructor closure, or Nothing for any other closure.
mapFamily :: ReplacementUse Source #
The tag of base's Map type and of the functions on Map, Set and
Multimap, which take and return it (see JIT.Config.ReplacementUse):
native code wins on maps below a few thousand keys, the common case,
the Haskell map above (JITbenchmarks2026-10-11-replacements.md), so
the family is left to the JIT.
mapReplaced :: Bool Source #
Whether the Map type is replaced by the Haskell WrapMap under the
current settings.
data UnboxedTypeTag Source #
Constructors
| CharTag | |
| FloatTag | |
| IntTag | |
| NatTag | |
| WitnessTag !Int | The value slot of a wide variable holding an unboxed constructor of this many fields (Unison.Runtime.Wide): the slot's word is the constructor's packed tag and the fields are in the slots below. |
Instances
| Show UnboxedTypeTag Source # | |
Defined in Unison.Runtime.Stack Methods showsPrec :: Int -> UnboxedTypeTag -> ShowS # show :: UnboxedTypeTag -> String # showList :: [UnboxedTypeTag] -> ShowS # | |
| Eq UnboxedTypeTag Source # | |
Defined in Unison.Runtime.Stack Methods (==) :: UnboxedTypeTag -> UnboxedTypeTag -> Bool # (/=) :: UnboxedTypeTag -> UnboxedTypeTag -> Bool # | |
| Ord UnboxedTypeTag Source # | |
Defined in Unison.Runtime.Stack Methods compare :: UnboxedTypeTag -> UnboxedTypeTag -> Ordering # (<) :: UnboxedTypeTag -> UnboxedTypeTag -> Bool # (<=) :: UnboxedTypeTag -> UnboxedTypeTag -> Bool # (>) :: UnboxedTypeTag -> UnboxedTypeTag -> Bool # (>=) :: UnboxedTypeTag -> UnboxedTypeTag -> Bool # max :: UnboxedTypeTag -> UnboxedTypeTag -> UnboxedTypeTag # min :: UnboxedTypeTag -> UnboxedTypeTag -> UnboxedTypeTag # | |
witnessTag :: Int -> Closure Source #
The witness closures of unboxed constructors (WitnessTag), one per
field count, so that writing one allocates nothing.
Constructors
| Stack | |
type XStack = (# Int#, Int#, Int#, MutableByteArray# (PrimState IO), MutableArray# (PrimState IO) Closure #) Source #
pattern XStack :: Int# -> Int# -> Int# -> MutableByteArray# RealWorld -> MutableArray# RealWorld Closure -> Stack Source #
packXStack :: XStack -> Stack Source #
unpackXStack :: Stack -> XStack Source #
type RecordVals = Vector Val Source #
A record's field values, in ascending field-name order. Slot i holds the
value of field i of the accompanying RecordShape.
recordVals :: Seg -> RecordVals Source #
A record's values from a segment: slot i holds the segment's i-th value
(the segments are stored backwards). Every element is an evaluated Val,
since native code reads the vector's elements as closures.
segToList :: Seg -> SegList Source #
Converts from the efficient stack form of a segment to the list representation. Segments are stored backwards, so this reverses the contents
A runtime value, which is either a boxed or unboxed value, but we may not know which.
When it represents a boxed value, getUnboxedVal is meaningless, but when it represents an unboxed value,
getBoxedVal tells us its type.
Constructors
| Val | |
Fields
| |
Bundled Patterns
| pattern CharVal :: Char -> Val | |
| pattern NatVal :: Word64 -> Val | |
| pattern DoubleVal :: Double -> Val | |
| pattern IntVal :: Int -> Val | |
| pattern BoolVal :: Bool -> Val | |
| pattern UnboxedVal :: Int -> UnboxedTypeTag -> Val | |
| pattern BoxedVal :: Closure -> Val | Matches a Val which is known to be boxed, and returns the closure portion. |
Instances
| Show Val Source # | |
| Eq Val Source # | The |
| Ord Val Source # | |
| ForeignConvention Val Source # | |
| BuiltinForeign (Ticket Val) Source # | |
| BuiltinForeign (TVar Val) Source # | |
| BuiltinForeign (IORef Val) Source # | |
| BuiltinForeign (MVar Val) Source # | |
| BuiltinForeign (Array Val) Source # | |
| BuiltinForeign (Promise Val) Source # | |
| BuiltinForeign (Deque Val) Source # | |
| BuiltinForeign (Map Val Val) Source # | |
| BuiltinForeign (MutableArray RealWorld Val) Source # | |
Defined in Unison.Runtime.Stack Methods builtinName :: Tagged (MutableArray RealWorld Val) String Source # wrapBuiltin :: MutableArray RealWorld Val -> Closure Source # maybeUnwrapBuiltin :: Closure -> Maybe (MutableArray RealWorld Val) Source # | |
type USeq = Deque Val Source #
Implementation for Unison sequences. | The runtime's lists. A strict deque: no thunks inside, so its structure can be read without evaluating anything.
frameDataSize :: K -> Int Source #
data RuntimePanic Source #
Instances
| Exception RuntimePanic Source # | |
Defined in Unison.Runtime.Stack Methods toException :: RuntimePanic -> SomeException # fromException :: SomeException -> Maybe RuntimePanic # displayException :: RuntimePanic -> String # backtraceDesired :: RuntimePanic -> Bool # | |
| Show RuntimePanic Source # | |
Defined in Unison.Runtime.Stack Methods showsPrec :: Int -> RuntimePanic -> ShowS # show :: RuntimePanic -> String # showList :: [RuntimePanic] -> ShowS # | |
marshalUnwrapForeignIO :: (HasCallStack, BuiltinForeign a) => Closure -> IO a Source #
pokeTag :: DebugCallStack => Stack -> Int -> IO () Source #
Store an unboxed tag to later match on. Often used to indicate the constructor of a data type that's been unpacked onto the stack, or some tag we're about to branch on.
pokeI :: Stack -> Int -> IO () Source #
Note: This is for poking an unboxed value that has the UNISON type int, not just any unboxed data.
defaultStackSlots :: Int Source #
The slots a fresh stack has. The JIT's ustack stress mode starts with
a tiny stack instead, so that growing it is exercised constantly.
type MCombs = RCombs Val Source #
The code the interpreter runs: MCode over resolved combinators and these values. (Defined here, below the JIT modules, so that the JIT handle can be a field of the code cache without an import cycle.)
nativeOutWords :: Int Source #
Words past the last slot of the unboxed stack that native code's
entry point writes its results to: ap, fp, sp, a count of frame
records, and up to eight records of three words. Must match
UNISON_JIT_OUT_WORDS in jit_rt.h.
nativeOutPtrs :: Int Source #
Pointers past the last slot of the boxed stack, where native code
hands heap pointers back so that the collector sees them: the handler
environment it was running with when it returned, then one environment
per Local frame record it wrote (see pushRecord in Machine.hs). Must
match UNISON_JIT_OUT_PTRS in jit_rt.h.
bstkSlots :: MutableArray RealWorld Closure -> Int Source #
The slots of a boxed stack: its size less the out-area.
bpoke :: DebugCallStack => Stack -> BVal -> IO () Source #
Store a boxed value. We don't bother nulling out the unboxed stack, it's extra work and there's nothing to garbage collect.
unsafePokeIasN :: DebugCallStack => Stack -> Int -> IO () Source #
Sometimes we get back an int from a foreign call which we want to use as a Nat. If we know it's positive and smaller than 2^63 then we can safely store the Int directly as a Nat without checks.
ensureGenerously :: Stack -> SZ -> IO Stack Source #
Like ensure, but grows by at least the stack's current size. Native
code pays for every growth by unwinding all its frames to the
interpreter, so it asks for room in big steps.
useg :: [Int] -> USeg Source #
Converts a list of integers representing an unboxed segment back into the appropriate segment. Segments are stored backwards in the runtime, so this reverses the list.
bseg :: [Closure] -> BSeg Source #
Converts a list of closures back to a boxed segment. Segments are stored backwards, so this reverses the contents.
segFromList :: SegList -> Seg Source #
Converts from the list representation of a segment to the efficient stack form. Segments are stored backwards, so this reverses the contents.
Unboxed type tags
natTypeTag :: Closure Source #
intTypeTag :: Closure Source #
hasNoAllocations :: Name -> Obligation Source #
data HashAlgorithm where Source #
Constructors
| HashAlgorithm :: forall a. HashAlgorithm a => Reference -> a -> HashAlgorithm |
Instances
| BuiltinForeign HashAlgorithm Source # | |
Defined in Unison.Runtime.Stack Methods builtinName :: Tagged HashAlgorithm String Source # wrapBuiltin :: HashAlgorithm -> Closure Source # maybeUnwrapBuiltin :: Closure -> Maybe HashAlgorithm Source # | |
Instances
| Eq Tls Source # | |
| BuiltinForeign Tls Source # | |
Defined in Unison.Runtime.Stack | |