Module

TsBridge.DefaultImpls

Package: purescript-ts-bridge
Repository: thought2/purescript-ts-bridge

#TypeVar Source

data TypeVar :: Symbol -> Typedata TypeVar (s :: Symbol)

Represents a monomorphized type variable. E.g. a Maybe a can become a Maybe (TypeVar "A"). It's useful to create some type aliases for variables that are used often, like: type A = TypeVar "A".

Constructors

TypeVar

#NTupleList Source

class NTupleList :: Type -> List' @Type Type -> Constraintclass NTupleList tok (xs :: List' Type)  where

Members

tsBridgeNTupleList :: tok -> Proxy xs -> TsBridgeM (Array TsType)

Instances

NTupleList tok Nil'
(TsBridgeBy tok a, NTupleList tok as) => NTupleList tok (Cons' a as)

#TsBridgeRecord Source

class TsBridgeRecord :: Type -> Row Type -> Constraintclass TsBridgeRecord tok r  where

Members

tsBridgeRecord :: tok -> Proxy (Record r) -> TsBridgeM TsType
tsBridge type class method implementation for the Record type

See this reference for details.

Instances

(RowToList r rl, TsBridgeRecordRL tok rl) => TsBridgeRecord tok r

#TsBridgeRecordRL Source

class TsBridgeRecordRL :: Type -> RowList Type -> Constraintclass TsBridgeRecordRL tok rl  where

Members

tsBridgeRecordRL :: tok -> Proxy rl -> TsBridgeM (Array TsRecordField)

Instances

TsBridgeRecordRL tok Nil
(TsBridgeBy tok t, TsBridgeRecordRL tok rl, IsSymbol s) => TsBridgeRecordRL tok (Cons s t rl)

#TsBridgeVariant Source

class TsBridgeVariant :: Type -> Row Type -> Constraintclass TsBridgeVariant tok r  where

Members

tsBridgeVariant :: tok -> Proxy (Variant r) -> TsBridgeM TsType
tsBridge type class method implementation for the Variant type

See this reference for details.

Instances

(RowToList r rl, TsBridgeVariantRL tok rl) => TsBridgeVariant tok r

#TsBridgeVariantEncodedFlat Source

class TsBridgeVariantEncodedFlat :: Type -> Symbol -> Row Type -> Constraintclass TsBridgeVariantEncodedFlat tok symTag r  where

Members

tsBridgeVariantEncodedFlat :: tok -> Proxy (VariantEncodedFlat symTag r) -> TsBridgeM TsType
tsBridge type class method implementation for the TsBridgeVariantEncodedFlat type

See this reference for details.

Instances

(RowToList r rl, TsBridgeVariantEncodedFlatRL tok symTag rl) => TsBridgeVariantEncodedFlat tok symTag r

#TsBridgeVariantEncodedFlatRL Source

class TsBridgeVariantEncodedFlatRL :: Type -> Symbol -> RowList Type -> Constraintclass TsBridgeVariantEncodedFlatRL tok symTag rl  where

Members

tsBridgeVariantEncodedFlatRL :: tok -> Proxy symTag -> Proxy rl -> TsBridgeM (Array TsType)
tsBridge type class method implementation for the TsBridgeVariantEncodedNested type

See this reference for details.

Instances

TsBridgeVariantEncodedFlatRL tok symTag Nil
(TsBridgeBy tok a, TsBridgeVariantEncodedFlatRL tok symTag rl, IsSymbol s, IsSymbol symTag) => TsBridgeVariantEncodedFlatRL tok symTag (Cons s a rl)

#TsBridgeVariantEncodedNested Source

class TsBridgeVariantEncodedNested :: Type -> Symbol -> Symbol -> Row Type -> Constraintclass TsBridgeVariantEncodedNested tok symTag symVal r  where

Members

tsBridgeVariantEncodedNested :: tok -> Proxy (VariantEncodedNested symTag symVal r) -> TsBridgeM TsType
tsBridge type class method implementation for the VariantEncodedNested type

See this reference for details.

Instances

(RowToList r rl, TsBridgeVariantEncodedNestedRL tok symTag symVal rl) => TsBridgeVariantEncodedNested tok symTag symVal r

#TsBridgeVariantEncodedNestedRL Source

class TsBridgeVariantEncodedNestedRL :: Type -> Symbol -> Symbol -> RowList Type -> Constraintclass TsBridgeVariantEncodedNestedRL tok symTag symVal rl  where

Members

tsBridgeVariantEncodedNestedRL :: tok -> Proxy symTag -> Proxy symVal -> Proxy rl -> TsBridgeM (Array TsType)

Instances

TsBridgeVariantEncodedNestedRL tok symTag symVal Nil
(TsBridgeBy tok t, TsBridgeVariantEncodedNestedRL tok symTag symVal rl, IsSymbol s, IsSymbol symTag, IsSymbol symVal) => TsBridgeVariantEncodedNestedRL tok symTag symVal (Cons s t rl)

#TsBridgeVariantRL Source

class TsBridgeVariantRL :: Type -> RowList Type -> Constraintclass TsBridgeVariantRL tok rl  where

Members

tsBridgeVariantRL :: tok -> Proxy rl -> TsBridgeM (Array TsType)

Instances

TsBridgeVariantRL tok Nil
(TsBridgeBy tok t, TsBridgeVariantRL tok rl, IsSymbol s) => TsBridgeVariantRL tok (Cons s t rl)

#tsBridgeArray Source

tsBridgeArray :: forall a tok. TsBridgeBy tok a => tok -> Proxy (Array a) -> TsBridgeM TsType

tsBridge type class method implementation for the Array type

See this reference for details.

#tsBridgeBoolean Source

tsBridgeBoolean :: Proxy Boolean -> TsBridgeM TsType

tsBridge type class method implementation for the Boolean type

See this reference for details.

#tsBridgeBooleanLit' Source

tsBridgeBooleanLit' :: forall h. Reflectable h Boolean => Proxy (Lit h Boolean) -> TsBridgeM TsType

#tsBridgeBooleanLitFalse Source

tsBridgeBooleanLitFalse :: Proxy (BooleanLit "false") -> TsBridgeM TsType

#tsBridgeBooleanLitTrue Source

tsBridgeBooleanLitTrue :: Proxy (BooleanLit "true") -> TsBridgeM TsType

#tsBridgeChar Source

tsBridgeChar :: Proxy Char -> TsBridgeM TsType

tsBridge type class method implementation for the Char type

See this reference for details.

#tsBridgeEffect Source

tsBridgeEffect :: forall tok a. TsBridgeBy tok a => tok -> Proxy (Effect a) -> TsBridgeM TsType

tsBridge type class method implementation for the Effect type

See this reference for details.

#tsBridgeEffectFn1 Source

tsBridgeEffectFn1 :: forall tok a1 b. TsBridgeBy tok a1 => TsBridgeBy tok b => tok -> Proxy (EffectFn1 a1 b) -> TsBridgeM TsType

#tsBridgeEffectFn2 Source

tsBridgeEffectFn2 :: forall tok a1 a2 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok b => tok -> Proxy (EffectFn2 a1 a2 b) -> TsBridgeM TsType

#tsBridgeEffectFn3 Source

tsBridgeEffectFn3 :: forall tok a1 a2 a3 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok a3 => TsBridgeBy tok b => tok -> Proxy (EffectFn3 a1 a2 a3 b) -> TsBridgeM TsType

#tsBridgeEffectFn4 Source

tsBridgeEffectFn4 :: forall tok a1 a2 a3 a4 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok a3 => TsBridgeBy tok a4 => TsBridgeBy tok b => tok -> Proxy (EffectFn4 a1 a2 a3 a4 b) -> TsBridgeM TsType

#tsBridgeEither Source

tsBridgeEither :: forall tok a b. TsBridgeBy tok a => TsBridgeBy tok b => tok -> Proxy (Either a b) -> TsBridgeM TsType

tsBridge type class method implementation for the Either type

See this reference for details.

#tsBridgeFn2 Source

tsBridgeFn2 :: forall tok a1 a2 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok b => tok -> Proxy (Fn2 a1 a2 b) -> TsBridgeM TsType

#tsBridgeFn3 Source

tsBridgeFn3 :: forall tok a1 a2 a3 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok a3 => TsBridgeBy tok b => tok -> Proxy (Fn3 a1 a2 a3 b) -> TsBridgeM TsType

#tsBridgeFn4 Source

tsBridgeFn4 :: forall tok a1 a2 a3 a4 b. TsBridgeBy tok a1 => TsBridgeBy tok a2 => TsBridgeBy tok a3 => TsBridgeBy tok a4 => TsBridgeBy tok b => tok -> Proxy (Fn4 a1 a2 a3 a4 b) -> TsBridgeM TsType

#tsBridgeFunction Source

tsBridgeFunction :: forall tok a b. TsBridgeBy tok a => TsBridgeBy tok b => tok -> Proxy (a -> b) -> TsBridgeM TsType

tsBridge type class method implementation for the a -> b (Function) type

See this reference for details.

#tsBridgeInt Source

tsBridgeInt :: Proxy Int -> TsBridgeM TsType

tsBridge type class method implementation for the Int type

See this reference for details.

#tsBridgeIntLit' Source

tsBridgeIntLit' :: forall h. Reflectable h Int => Proxy (Lit h Int) -> TsBridgeM TsType

#tsBridgeMaybe Source

tsBridgeMaybe :: forall tok a. TsBridgeBy tok a => tok -> Proxy (Maybe a) -> TsBridgeM TsType

tsBridge type class method implementation for the Maybe type

See this reference for details.

#tsBridgeNTuple Source

tsBridgeNTuple :: forall tok xs. NTupleList tok xs => tok -> Proxy (NTuple xs) -> TsBridgeM TsType

#tsBridgeNewtype Source

tsBridgeNewtype :: forall tok a t. Newtype a t => TsBridgeBy tok t => tok -> { moduleName :: String, typeArgs :: Array (String /\ (TsBridgeM TsType)), typeName :: String } -> Proxy a -> TsBridgeM TsType

tsBridge type class method implementation for newtypes

#tsBridgeNull Source

tsBridgeNull :: Proxy Null -> TsBridgeM TsType

#tsBridgeNullable Source

tsBridgeNullable :: forall a tok. TsBridgeBy tok a => tok -> Proxy (Nullable a) -> TsBridgeM TsType

tsBridge type class method implementation for the Nullable type.

See this reference for details.

#tsBridgeNumber Source

tsBridgeNumber :: Proxy Number -> TsBridgeM TsType

tsBridge type class method implementation for the Number type.

See this reference for details.

#tsBridgeObject Source

tsBridgeObject :: forall tok a. TsBridgeBy tok a => tok -> Proxy (Object a) -> TsBridgeM TsType

#tsBridgeOneOf Source

tsBridgeOneOf :: forall a b tok. TsBridgeBy tok a => TsBridgeBy tok b => tok -> Proxy (OneOf a b) -> TsBridgeM TsType

tsBridge type class method implementation for the OneOf type.

See this reference for details.

#tsBridgeOpaqueType Source

tsBridgeOpaqueType :: forall a. { moduleName :: String, typeArgs :: Array (String /\ (TsBridgeM TsType)), typeName :: String } -> Proxy a -> TsBridgeM TsType

tsBridge type class method implementation for opaque types

#tsBridgePromise Source

tsBridgePromise :: forall tok a. TsBridgeBy tok a => tok -> Proxy (Promise a) -> TsBridgeM TsType

tsBridge type class method implementation for the Promise type.

See this reference for details.

#tsBridgeString Source

tsBridgeString :: Proxy String -> TsBridgeM TsType

tsBridge type class method implementation for the String type

See this reference for details.

#tsBridgeStringLit Source

tsBridgeStringLit :: forall sym. IsSymbol sym => Proxy (StringLit sym) -> TsBridgeM TsType

tsBridge type class method implementation for string literal types.

#tsBridgeStringLit' Source

tsBridgeStringLit' :: forall h. Reflectable h String => Proxy (Lit h String) -> TsBridgeM TsType

#tsBridgeTuple Source

tsBridgeTuple :: forall tok a b. TsBridgeBy tok a => TsBridgeBy tok b => tok -> Proxy (Tuple a b) -> TsBridgeM TsType

tsBridge type class method implementation for the Tuple type

See this reference for details.

#tsBridgeTypeVar Source

tsBridgeTypeVar :: forall s. IsSymbol s => Proxy (TypeVar s) -> TsBridgeM TsType

tsBridge type class method implementation for type variables. This is needed because polymorphic values cannot be exported directly. They have to be monomorphized: E.g. something of type Maybe a needs to be typed Maybe (Var "A") to be exported.

#tsBridgeUndefined Source

tsBridgeUndefined :: Proxy Undefined -> TsBridgeM TsType

tsBridge type class method implementation for the Undefined type.

#tsBridgeUnit Source

tsBridgeUnit :: Proxy Unit -> TsBridgeM TsType

tsBridge type class method implementation for the Unit type

See this reference for details.

Modules: TsBridge; TsBridge.Class; TsBridge.Cli; TsBridge.Core; TsBridge.DefaultImpls; TsBridge.Monad; TsBridge.Types; TsBridge.Types.Intersection; TsBridge.Types.Lit; TsBridge.Types.NTuple; TsBridge.Types.RecordUnion; TsBridge.Types.TsRecord