GenTemporal
- Companion
- object
Document{}
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
- Inhertied from
- ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
- Inhertied from
- ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
- Inhertied from
- ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
- Inhertied from
- ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
- Inhertied from
- ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
- Inhertied from
- ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
- Inhertied from
- ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
- Inhertied from
- ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
- Inhertied from
- ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
- Inhertied from
- ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
- Inhertied from
- ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
- Inhertied from
- ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
- Inhertied from
- ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
- Inhertied from
- ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
- Inhertied from
- ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
- Inhertied from
- ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
- Inhertied from
- ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
- Inhertied from
- ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
- Inhertied from
- ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
- Inhertied from
- ApplyArityFunctions
Value members
Methods
Implicitly added by genTemporalForOptionT
Returns an effect that either completes with the result of the source within
the specified time
the specified time
duration
or otherwise evaluates the fallback
.The source is cancelled in the event that it takes longer than
the
happening immediately after that.
the
FiniteDuration
to complete, the evaluation of the fallbackhappening immediately after that.
- Value Params
- duration
-
is the time span for which we wait for the source to
complete; in the event that the specified time has passed without
the source completing, thefallback
gets evaluated - fallback
-
is the task evaluated after the duration has passed and
the source canceled
Implicitly added by genTemporalForOptionT
Returns an effect that either completes with the result of the source within
the specified time
the specified time
duration
or otherwise raises a TimeoutException
.The source is cancelled in the event that it takes longer than
the specified time duration to complete.
the specified time duration to complete.
- Value Params
- duration
-
is the time span for which we wait for the source to
complete; in the event that the specified time has passed without
the source completing, aTimeoutException
is raised
Implicitly added by genTemporalForEitherT
Returns an effect that either completes with the result of the source within
the specified time
the specified time
duration
or otherwise evaluates the fallback
.The source is cancelled in the event that it takes longer than
the
happening immediately after that.
the
FiniteDuration
to complete, the evaluation of the fallbackhappening immediately after that.
- Value Params
- duration
-
is the time span for which we wait for the source to
complete; in the event that the specified time has passed without
the source completing, thefallback
gets evaluated - fallback
-
is the task evaluated after the duration has passed and
the source canceled
Implicitly added by genTemporalForEitherT
Returns an effect that either completes with the result of the source within
the specified time
the specified time
duration
or otherwise raises a TimeoutException
.The source is cancelled in the event that it takes longer than
the specified time duration to complete.
the specified time duration to complete.
- Value Params
- duration
-
is the time span for which we wait for the source to
complete; in the event that the specified time has passed without
the source completing, aTimeoutException
is raised
Implicitly added by genTemporalForKleisli
Returns an effect that either completes with the result of the source within
the specified time
the specified time
duration
or otherwise evaluates the fallback
.The source is cancelled in the event that it takes longer than
the
happening immediately after that.
the
FiniteDuration
to complete, the evaluation of the fallbackhappening immediately after that.
- Value Params
- duration
-
is the time span for which we wait for the source to
complete; in the event that the specified time has passed without
the source completing, thefallback
gets evaluated - fallback
-
is the task evaluated after the duration has passed and
the source canceled
Implicitly added by genTemporalForKleisli
Returns an effect that either completes with the result of the source within
the specified time
the specified time
duration
or otherwise raises a TimeoutException
.The source is cancelled in the event that it takes longer than
the specified time duration to complete.
the specified time duration to complete.
- Value Params
- duration
-
is the time span for which we wait for the source to
complete; in the event that the specified time has passed without
the source completing, aTimeoutException
is raised
Returns an effect that either completes with the result of the source within
the specified time
the specified time
duration
or otherwise evaluates the fallback
.The source is cancelled in the event that it takes longer than
the
happening immediately after that.
the
FiniteDuration
to complete, the evaluation of the fallbackhappening immediately after that.
- Value Params
- duration
-
is the time span for which we wait for the source to
complete; in the event that the specified time has passed without
the source completing, thefallback
gets evaluated - fallback
-
is the task evaluated after the duration has passed and
the source canceled
Returns an effect that either completes with the result of the source within
the specified time
the specified time
duration
or otherwise raises a TimeoutException
.The source is cancelled in the event that it takes longer than
the specified time duration to complete.
the specified time duration to complete.
- Value Params
- duration
-
is the time span for which we wait for the source to
complete; in the event that the specified time has passed without
the source completing, aTimeoutException
is raised
Inherited methods
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by genTemporalForOptionT
Pair the result of function application with
A
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
}}}
res0: Option[(String, Int)] = Some((42,42))
}}}
- Inhertied from
- Functor
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by genTemporalForOptionT
Pair
A
with the result of function application.Example:
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
- Inhertied from
- FlatMap
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by genTemporalForOptionT
Execute an action repeatedly as long as the given
returns
Discards results.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Discards results.
- Inhertied from
- Monad
Implicitly added by genTemporalForOptionT
Races the evaluation of two fibers that returns the Outcome of the
winner. The winner of the race is considered to be the first fiber that
completes with an outcome. The loser of the race is canceled before
returning.
winner. The winner of the race is considered to be the first fiber that
completes with an outcome. The loser of the race is canceled before
returning.
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by genTemporalForOptionT
Alias for productR.
- Inhertied from
- Apply
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by genTemporalForOptionT
Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.unzip(List((1,2), (3, 4)))
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
- Inhertied from
- Functor
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by genTemporalForOptionT
Handle any error, by mapping it to an
A
value.- See also
- handleErrorWith to map to an
F[A]
value instead of simply anA
value.recover to only recover from certain errors. - Inhertied from
- ApplicativeError
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by genTemporalForOptionT
Replaces the
A
value in F[A]
with the supplied value.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
}}}
res0: List[String] = List(hello, hello, hello)
}}}
- Inhertied from
- Functor
def attemptNarrow[EE <: Throwable, A](fa: F[A])(tag: ClassTag[EE], ev: EE <:< E): F[Either[EE, A]]
Implicitly added by genTemporalForOptionT
Similar to attempt, but it only handles errors of type
EE
.- Inhertied from
- ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by genTemporalForOptionT
Convert from scala.Option
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int]
, "Empty")
res1: scala.Either[String, Int] = Left(Empty)
}}}
res1: scala.Either[String, Int] = Left(Empty)
}}}
- Inhertied from
- ApplicativeError
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by genTemporalForOptionT
Convert from scala.Either
Example:
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit]
.fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromEither(Left(()))
res1: scala.Option[Nothing] = None
}}}
res1: scala.Option[Nothing] = None
}}}
- Inhertied from
- ApplicativeError
Implicitly added by genTemporalForOptionT
Specifies an effect that is always invoked after evaluation of
completes, regardless of the outcome.
fa
completes, regardless of the outcome.
- Value Params
- fa
-
The effect that is run after
fin
is registered. - fin
-
The effect to run in the event of a cancellation or error.
- See also
- guaranteeCase for a more powerful variantOutcome for the various outcomes of evaluation
- Inhertied from
- MonadCancel
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by genTemporalForOptionT
- Inhertied from
- FlatMap
def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by genTemporalForOptionT
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.acquire
is uncancelable.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action
- release
-
the lifecycle release action which depends on the outcome of
use
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- See also
- bracketFull for a more powerful variantResource for a composable datatype encoding of effectful lifecycles
- Inhertied from
- MonadCancel
@noop
def whileM[G <: ([_$2] =>> Any), A](p: F[Boolean])(body: => F[A])(G: Alternative[G]): F[G[A]]
Implicitly added by genTemporalForOptionT
Execute an action repeatedly as long as the given
returns
Collects the results into an arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Collects the results into an arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by genTemporalForOptionT
This repeats an F until we get defined values. This can be useful
for polling type operations on State (or RNG) Monads, or in effect
monads.
for polling type operations on State (or RNG) Monads, or in effect
monads.
- Inhertied from
- FlatMap
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by genTemporalForOptionT
Tuple the values in fa with the result of applying a function
with the value
with the value
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
}}}
res0: Option[(Int, String)] = Some((42,42))
}}}
- Inhertied from
- Functor
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by genTemporalForOptionT
Simulates an if/else-if/else in the context of an F. It evaluates conditions until
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
{{{
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
- See also
- See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inhertied from
- Monad
Implicitly added by genTemporalForOptionT
Registers a finalizer that is invoked if cancellation is observed
during the evaluation of
without encountering a cancellation, the finalizer is unregistered
before proceeding.
during the evaluation of
fa
. If the evaluation of fa
completeswithout encountering a cancellation, the finalizer is unregistered
before proceeding.
During finalization, all actively registered finalizers are run exactly
once. The order by which finalizers are run is dictated by nesting:
innermost finalizers are run before outermost finalizers. For example,
in the following program, the finalizer
once. The order by which finalizers are run is dictated by nesting:
innermost finalizers are run before outermost finalizers. For example,
in the following program, the finalizer
f1
is run before the finalizerf2
:{{{
F.onCancel(F.onCancel(F.canceled, f1), f2)
}}}
If a finalizer throws an error during evaluation, the error is suppressed,
and implementations may choose to report it via a side channel. Finalizers
are always uncancelable, so cannot otherwise be interrupted.
and implementations may choose to report it via a side channel. Finalizers
are always uncancelable, so cannot otherwise be interrupted.
- Value Params
- fa
-
The effect that is evaluated after
fin
is registered. - fin
-
The finalizer to register before evaluating
fa
.
- Inhertied from
- MonadCancel
def point[A](a: A): F[A]
Implicitly added by genTemporalForOptionT
point
lifts any value into a Monoidal Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> InvariantMonoidal[Option]
.point(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- InvariantMonoidal
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by genTemporalForOptionT
Similar to map2 but uses Eval to allow for laziness in the
argument. This can allow for "short-circuiting" of computations.
F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
map2Eval
does not short-circuitcomputations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example,
but
result of
that the result of
x.map2(bomb)(_ + _)
would result in an error,but
map2Eval
"short-circuits" the computation. x
is None
and thus theresult of
bomb
doesn't even need to be evaluated in order to determinethat the result of
map2Eval
should be None
.{{{
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
- Inhertied from
- Apply
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by genTemporalForOptionT
Convert from cats.data.Validated
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit]
.fromValidated(1.valid[Unit]
)
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromValidated(().invalid[Int]
)
res1: scala.Option[Int] = None
}}}
res1: scala.Option[Int] = None
}}}
- Inhertied from
- ApplicativeError
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForOptionT
Execute an action repeatedly until its result fails to satisfy the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
def raiseError[A](e: E): F[A]
Implicitly added by genTemporalForOptionT
Lift an error into the
F
context.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A]
= Either[String, A]
scala> divide[ErrorOr]
(6, 3)
res0: ErrorOr[Int] = Right(2)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr]
(6, 0)
res1: ErrorOr[Int] = Left(division by zero)
}}}
res1: ErrorOr[Int] = Left(division by zero)
}}}
- Inhertied from
- ApplicativeError
def fromTry[A](t: Try[A])(ev: Throwable <:< E): F[A]
Implicitly added by genTemporalForOptionT
If the error type is Throwable, we can convert from a scala.util.Try
- Inhertied from
- ApplicativeError
def composeFunctor[G <: ([_$3] =>> Any)](evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by genTemporalForOptionT
Compose Invariant
using F's
F[_]
and Functor G[_]
then produce Invariant[F[G[_]]]
using F's
imap
and G's map
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def composeApply[G <: ([_$2] =>> Any)](evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by genTemporalForOptionT
- Inhertied from
- InvariantSemigroupal
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by genTemporalForOptionT
Recover from certain errors by mapping them to an
F[A]
value.- See also
- handleErrorWith to handle any/all errors.recover to recover from certain errors by mapping them to
A
values. - Inhertied from
- ApplicativeError
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by genTemporalForOptionT
"flatten" a nested
F
of F
structure into a single-layer F
structure.This is also commonly called
join
.Example:
{{{
scala> import cats.Eval
scala> import cats.implicits._
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]
] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
- Inhertied from
- FlatMap
def untilM[G <: ([_$4] =>> Any), A](f: F[A])(cond: => F[Boolean])(G: Alternative[G]): F[G[A]]
Implicitly added by genTemporalForOptionT
Execute an action repeatedly until the
The condition is evaluated after the loop body. Collects results into an
arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
condition returns true
.The condition is evaluated after the loop body. Collects results into an
arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
def unit: F[Unit]
Implicitly added by genTemporalForOptionT
Returns an
F[Unit]
value, equivalent with pure(())
.A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a
returned reference (e.g. it can be a
val
).Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.unit
res0: Option[Unit] = Some(())
}}}
res0: Option[Unit] = Some(())
}}}
- Inhertied from
- Applicative
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by genTemporalForOptionT
Execute an action repeatedly until the
The condition is evaluated after the loop body. Discards results.
Boolean
condition returns true
.The condition is evaluated after the loop body. Discards results.
- Inhertied from
- Monad
Implicitly added by genTemporalForOptionT
The child fiber is canceled in two cases: either the resource goes out
of scope or the parent fiber is cancelled. If the child fiber terminates
before one of these cases occurs, then cancellation is a no-op. This
avoids fiber leaks because the child fiber is always canceled before
the parent fiber drops the reference to it.
of scope or the parent fiber is cancelled. If the child fiber terminates
before one of these cases occurs, then cancellation is a no-op. This
avoids fiber leaks because the child fiber is always canceled before
the parent fiber drops the reference to it.
{{{
// Starts a fiber that continously prints "A".
// After 10 seconds, the resource scope exits so the fiber is canceled.
F.background(F.delay(println("A")).foreverM).use { _ =>
F.sleep(10.seconds)
}
// After 10 seconds, the resource scope exits so the fiber is canceled.
F.background(F.delay(println("A")).foreverM).use { _ =>
F.sleep(10.seconds)
}
}}}
- Value Params
- fa
-
the effect for the spawned fiber
- Inhertied from
- GenSpawn
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by genTemporalForOptionT
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the left.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
- Inhertied from
- Functor
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by genTemporalForOptionT
Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.- See also
- handleError to handle any error by simply mapping it to an
A
value instead of anF[A]
.recoverWith to recover from only certain errors. - Inhertied from
- ApplicativeError
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by genTemporalForOptionT
Apply a monadic function and discard the result while keeping the effect.
{{{
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
- Inhertied from
- FlatMap
Implicitly added by genTemporalForOptionT
Masks cancellation on the current fiber. The argument to
Polling causes a fiber to unmask within a masked region so that
cancellation can be observed again.
body
of typePoll[F]
is a natural transformation F ~> F
that enables polling.Polling causes a fiber to unmask within a masked region so that
cancellation can be observed again.
In the following example, cancellation can be observed only within
and nowhere else:
fb
and nowhere else:
{{{
F.uncancelable { poll =>
fa *> poll(fb) *> fc
}
fa *> poll(fb) *> fc
}
}}}
If a fiber is canceled while it is masked, the cancellation is suppressed
for as long as the fiber remains masked. Whenever the fiber is completely
unmasked again, the cancellation will be respected.
for as long as the fiber remains masked. Whenever the fiber is completely
unmasked again, the cancellation will be respected.
Masks can also be stacked or nested within each other. If multiple masks
are active, all masks must be undone so that cancellation can be observed.
In order to completely unmask within a multi-masked region, the poll
corresponding to each mask must be applied, innermost-first.
are active, all masks must be undone so that cancellation can be observed.
In order to completely unmask within a multi-masked region, the poll
corresponding to each mask must be applied, innermost-first.
{{{
F.uncancelable { p1 =>
F.uncancelable { p2 =>
fa *> p2(p1(fb)) *> fc
}
}
F.uncancelable { p2 =>
fa *> p2(p1(fb)) *> fc
}
}
}}}
The following operations are no-ops:
-
Polling in the wrong order
-
Applying the same poll more than once:
poll(poll(fa))
-
Applying a poll bound to one fiber within another fiber
- Inhertied from
- MonadCancel
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by genTemporalForOptionT
Turns a successful value into an error if it does not satisfy a given predicate.
- Inhertied from
- MonadError
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by genTemporalForOptionT
Sequentially compose two actions, discarding any value produced by the second. This variant of
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
- Inhertied from
- FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by genTemporalForOptionT
Sequentially compose two actions, discarding any value produced by the first. This variant of
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
- Inhertied from
- FlatMap
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by genTemporalForOptionT
Execute a callback on certain errors, then rethrow them.
Any non matching error is rethrown as well.
Any non matching error is rethrown as well.
In the following example, only one of the errors is logged,
but they are both rethrown, to be possibly handled by another
layer of the program:
but they are both rethrown, to be possibly handled by another
layer of the program:
{{{
scala> import cats., data., implicits._
scala> import cats., data., implicits._
scala> case class Err(msg: String)
scala> type F[A]
= EitherT[State[String, *]
, Err, A]
scala> val action: PartialFunction[Err, F[Unit]
] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int]
= (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]
) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
- Inhertied from
- ApplicativeError
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Implicitly added by genTemporalForOptionT
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- Inhertied from
- ApplicativeError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by genTemporalForOptionT
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or map
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
Usage of
redeem
subsumes handleError because:{{{
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- ApplicativeError
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by genTemporalForOptionT
Lift a function f to operate on Functors
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
- Inhertied from
- Functor
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by genTemporalForOptionT
Turns a successful value into an error specified by the
error
function if it does not satisfy a given predicate.- Inhertied from
- MonadError
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForOptionT
Apply a monadic function iteratively until its result satisfies
the given predicate and return that result.
the given predicate and return that result.
- Inhertied from
- Monad
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by genTemporalForOptionT
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or bind
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
Usage of
redeemWith
subsumes handleErrorWith because:{{{
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
Usage of
redeemWith
also subsumes flatMap because:{{{
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- bind
-
is the function that gets to transform the source
in case of success - fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- MonadError
def parTraverseN[T <: ([_$3] =>> Any), A, B](n: Int)(ta: T[A])(f: A => F[B])(evidence$2: Traverse[T]): F[T[B]]
Implicitly added by genTemporalForOptionT
Like
Note that the semantics of this operation aim to maximise
fairness: when a spot to execute becomes available, every task
has a chance to claim it, and not only the next
Parallel.parTraverse
, but limits the degree of parallelism.Note that the semantics of this operation aim to maximise
fairness: when a spot to execute becomes available, every task
has a chance to claim it, and not only the next
n
tasks in ta
- Inhertied from
- GenConcurrent
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by genTemporalForOptionT
Given
fa
and n
, apply fa
n
times to construct an F[List[A]]
value.Example:
{{{
scala> import cats.data.State
{{{
scala> import cats.data.State
scala> type Counter[A]
= State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
- Inhertied from
- Applicative
Implicitly added by genTemporalForOptionT
A low-level primitive for starting the concurrent evaluation of a fiber.
Returns a Fiber that can be used to wait for a fiber or cancel it.
Returns a Fiber that can be used to wait for a fiber or cancel it.
start is a cancellation-unsafe function; it is recommended to
use the safer variant, background, to spawn fibers.
use the safer variant, background, to spawn fibers.
- Value Params
- fa
-
the effect for the fiber
- See also
- background for the safer, recommended variant
- Inhertied from
- GenSpawn
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForOptionT
Apply a monadic function iteratively until its result fails
to satisfy the given predicate and return that result.
to satisfy the given predicate and return that result.
- Inhertied from
- Monad
def composeContravariantMonoidal[G <: ([_$3] =>> Any)](evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by genTemporalForOptionT
Compose an
Applicative[F]
and a ContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.byString, Int
scala> val strLength: Order[String] = Order.byString, Int
scala> val stringOrders: List[Order[String]
] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List]
.composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the
//
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
product
of the string order list and the int order list//
p
contains a list of the following orders:// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
- Inhertied from
- Applicative
def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by genTemporalForOptionT
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.If
an exception, the exception is returned.
use
succeeds the returned value B
is returned. If use
returnsan exception, the exception is returned.
acquire
is uncancelable by default, but can be unmasked.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action which can be canceled
- release
-
the lifecycle release action which depends on the outcome of
use
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- Inhertied from
- MonadCancel
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by genTemporalForOptionT
An
This function combines the effects of the
in the order in which they are given.
if-then-else
lifted into the F
context.This function combines the effects of the
fcond
condition and of the two branches,in the order in which they are given.
The value of the result is, depending on the value of the condition,
the value of the first argument, or the value of the second argument.
the value of the first argument, or the value of the second argument.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val b1: Option[Boolean]
= Some(true)
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val b2: Option[Boolean]
= Some(false)
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val b3: Option[Boolean]
= Some(true)
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
}}}
- Inhertied from
- Apply
def catchNonFatal[A](a: => A)(ev: Throwable <:< E): F[A]
Implicitly added by genTemporalForOptionT
Often E is Throwable. Here we try to call pure or catch
and raise.
and raise.
- Inhertied from
- ApplicativeError
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by genTemporalForOptionT
Lifts
if
to FunctorExample:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
}}}
res0: List[Int] = List(1, 0, 0)
}}}
- Inhertied from
- Functor
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by genTemporalForOptionT
Similar to attempt, but wraps the result in a data.EitherT for
convenience.
convenience.
- Inhertied from
- ApplicativeError
Implicitly added by genTemporalForOptionT
An effect that requests self-cancellation on the current fiber.
In the following example, the fiber requests self-cancellation in a masked
region, so cancellation is suppressed until the fiber is completely
unmasked.
region, so cancellation is suppressed until the fiber is completely
unmasked.
fa
will run but fb
will not.{{{
F.uncancelable { _ =>
F.canceled *> fa
} *> fb
F.canceled *> fa
} *> fb
}}}
- Inhertied from
- MonadCancel
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by genTemporalForOptionT
Returns the given argument (mapped to Unit) if
unit lifted into F.
cond
is true
, otherwise,unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
res0: List[Unit] = List((), (), ())
scala> Applicative[List]
.whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
res1: List[Unit] = List(())
scala> Applicative[List]
.whenA(true)(List.empty[Int]
)
res2: List[Unit] = List()
res2: List[Unit] = List()
scala> Applicative[List]
.whenA(false)(List.empty[Int]
)
res3: List[Unit] = List(())
}}}
res3: List[Unit] = List(())
}}}
- Inhertied from
- Applicative
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by genTemporalForOptionT
iterateForeverM is almost exclusively useful for effect types. For instance,
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
- Inhertied from
- FlatMap
Implicitly added by genTemporalForOptionT
Like
Parallel.parSequence
, but limits the degree of parallelism.- Inhertied from
- GenConcurrent
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by genTemporalForOptionT
Like an infinite loop of >> calls. This is most useful effect loops
that you want to run forever in for instance a server.
that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing]
.
Be careful using this.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
- Inhertied from
- FlatMap
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by genTemporalForOptionT
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a
implemented as a type cast. It could be implemented as
according to the functor laws, that should be equal to
cast is often much more performant.
See this example
of
equality this can result in a
ClassCastException
, because it isimplemented as a type cast. It could be implemented as
map(identity)
, butaccording to the functor laws, that should be equal to
fa
, and a typecast is often much more performant.
See this example
of
widen
creating a ClassCastException
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
- Inhertied from
- Functor
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by genTemporalForOptionT
- Inhertied from
- ApplyArityFunctions
def catchNonFatalEval[A](a: Eval[A])(ev: Throwable <:< E): F[A]
Implicitly added by genTemporalForOptionT
Often E is Throwable. Here we try to call pure or catch
and raise
and raise
- Inhertied from
- ApplicativeError
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by genTemporalForOptionT
Handle errors by turning them into scala.util.Either values.
If there is no error, then an
scala.util.Right
value will be returned instead.All non-fatal errors should be handled by this method.
- Inhertied from
- ApplicativeError
Implicitly added by genTemporalForOptionT
Introduces a fairness boundary that yields control back to the scheduler
of the runtime system. This allows the carrier thread to resume execution
of another waiting fiber.
of the runtime system. This allows the carrier thread to resume execution
of another waiting fiber.
Note that
have the liberty to interpret this method to their liking as long as it
obeys the respective laws. For example, a lawful, but atypical,
implementation of this function is
boundary is a no-op.
cede
is merely a hint to the runtime system; implementationshave the liberty to interpret this method to their liking as long as it
obeys the respective laws. For example, a lawful, but atypical,
implementation of this function is
F.unit
, in which case the fairnessboundary is a no-op.
- Inhertied from
- GenSpawn
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by genTemporalForOptionT
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in
the implementing type already had a built-in
.map
method.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val m: Map[Int, String]
= Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
- Inhertied from
- Functor
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by genTemporalForOptionT
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the right.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
- Inhertied from
- Functor
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by genTemporalForOptionT
Keeps calling
f
until a scala.util.Right[B]
is returned.Based on Phil Freeman's
Stack Safety for Free.
Stack Safety for Free.
Implementations of this method should use constant stack space relative to
f
.- Inhertied from
- FlatMap
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by genTemporalForOptionT
Inverse of
attempt
Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]
] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]
] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by genTemporalForOptionT
Returns the given argument (mapped to Unit) if
otherwise, unit lifted into F.
cond
is false
,otherwise, unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
res0: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
res1: List[Unit] = List((), (), ())
scala> Applicative[List]
.unlessA(true)(List.empty[Int]
)
res2: List[Unit] = List(())
res2: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List.empty[Int]
)
res3: List[Unit] = List()
}}}
res3: List[Unit] = List()
}}}
- Inhertied from
- Applicative
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by genTemporalForOptionT
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into
then recovers the original value or error back into
F
.Note that if the effect returned by
f
fails, the resulting effect will fail too.Alias for
fa.attempt.flatTap(f).rethrow
for convenience.Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]
): Try[String]
= result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int]
= Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int]
= Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def void[A](fa: F[A]): F[Unit]
Implicitly added by genTemporalForOptionT
Empty the fa of the values, preserving the structure
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.void(List(1,2,3))
res0: List[Unit] = List((), (), ())
}}}
res0: List[Unit] = List((), (), ())
}}}
- Inhertied from
- Functor
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by genTemporalForOptionT
Alias for productL.
- Inhertied from
- Apply
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by genTemporalForOptionT
if
lifted into monad.- Inhertied from
- FlatMap
Implicitly added by genTemporalForOptionT
Specifies an effect that is always invoked after evaluation of
completes, but depends on the outcome.
fa
completes, but depends on the outcome.
- Value Params
- fa
-
The effect that is run after
fin
is registered. - fin
-
A function that returns the effect to run based on the
outcome.
- See also
- bracketCase for a more powerful variantOutcome for the various outcomes of evaluation
- Inhertied from
- MonadCancel
def compose[G <: ([_$2] =>> Any)](evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by genTemporalForOptionT
Compose an
Applicative[F]
and an Applicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Applicative[List]
.compose[Option]
scala> alo.pure(3)
res0: List[Option[Int] ] = List(Some(3))
res0: List[Option[Int] ] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Applicative
def compose[G <: ([_$2] =>> Any)](evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by genTemporalForOptionT
Compose Invariant
F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def compose[G <: ([_$3] =>> Any)](evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by genTemporalForOptionT
Compose an
Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Apply[List]
.compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Apply
def compose[G <: ([_$6] =>> Any)](evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by genTemporalForOptionT
- Inhertied from
- Functor
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForOptionT
Execute an action repeatedly until its result satisfies the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
Implicitly added by genTemporalForOptionT
Races the evaluation of two fibers and returns the Outcome of both. If
the race is canceled before one or both participants complete, then
then whichever ones are incomplete are canceled.
the race is canceled before one or both participants complete, then
then whichever ones are incomplete are canceled.
Implicitly added by genTemporalForOptionT
Races the evaluation of two fibers that returns the result of the winner,
except in the case of cancellation.
except in the case of cancellation.
The semantics of race are described by the following rules:
-
If the winner completes with Succeeded, the race returns the
successful value. The loser is canceled before returning. -
If the winner completes with Errored, the race raises the error.
The loser is canceled before returning. -
If the winner completes with Canceled, the race returns the
result of the loser, consistent with the first two rules. -
If both the winner and loser complete with Canceled, the race
is canceled. -
If the race is masked and is canceled because both participants
canceled, the fiber will block indefinitely.
- Value Params
- fa
-
the effect for the first racing fiber
- fb
-
the effect for the second racing fiber
- See also
- raceOutcome for a variant that returns the outcome of the winner.
- Inhertied from
- GenSpawn
Implicitly added by genTemporalForOptionT
A non-terminating effect that never completes, which causes a fiber to
semantically block indefinitely. This is the purely functional,
asynchronous equivalent of an infinite while loop in Java, but no
native threads are blocked.
semantically block indefinitely. This is the purely functional,
asynchronous equivalent of an infinite while loop in Java, but no
native threads are blocked.
A fiber that is suspended in never can be canceled if it is
completely unmasked before it suspends:
completely unmasked before it suspends:
{{{
// ignoring race conditions between
F.never.start.flatMap(_.cancel) <-> F.unit
start
and cancel
F.never.start.flatMap(_.cancel) <-> F.unit
}}}
However, if the fiber is masked, cancellers will be semantically blocked
forever:
forever:
{{{
// ignoring race conditions between
F.uncancelable(_ => F.never).start.flatMap(_.cancel) <-> F.never
start
and cancel
F.uncancelable(_ => F.never).start.flatMap(_.cancel) <-> F.never
}}}
- Inhertied from
- GenSpawn
Implicitly added by genTemporalForOptionT
Races the evaluation of two fibers and returns the result of both.
The following rules describe the semantics of both:
-
If the winner completes with Succeeded, the race waits for the
loser to complete. -
If the winner completes with Errored, the race raises the error.
The loser is canceled. -
If the winner completes with Canceled, the loser and the race
are canceled as well. -
If the loser completes with Succeeded, the race returns the
successful value of both fibers. -
If the loser completes with Errored, the race returns the error.
-
If the loser completes with Canceled, the race is canceled.
-
If the race is canceled before one or both participants complete,
then whichever ones are incomplete are canceled. -
If the race is masked and is canceled because one or both
participants canceled, the fiber will block indefinitely.
- Value Params
- fa
-
the effect for the first racing fiber
- fb
-
the effect for the second racing fiber
- See also
- Inhertied from
- GenSpawn
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by genTemporalForOptionT
Recover from certain errors by mapping them to an
A
value.- See also
- handleError to handle any/all errors.recoverWith to recover from certain errors by mapping them to
F[A]
values. - Inhertied from
- ApplicativeError
Implicitly added by genTemporalForOptionT
Analogous to productR, but suppresses short-circuiting behavior
except for cancellation.
except for cancellation.
- Inhertied from
- MonadCancel
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by genTemporalForOptionT
Alias for ap.
- Inhertied from
- Apply
Implicitly added by genTemporalForOptionT
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.acquire
is uncancelable.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action
- release
-
the lifecycle release action
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- See also
- bracketCase for a more powerful variantResource for a composable datatype encoding of effectful lifecycles
- Inhertied from
- MonadCancel
def pure[A](x: A): F[A]
Implicitly added by genTemporalForOptionT
pure
lifts any value into the Applicative Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.pure(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- Applicative
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by genTemporalForEitherT
Pair the result of function application with
A
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
}}}
res0: Option[(String, Int)] = Some((42,42))
}}}
- Inhertied from
- Functor
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by genTemporalForEitherT
Pair
A
with the result of function application.Example:
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
- Inhertied from
- FlatMap
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by genTemporalForEitherT
Execute an action repeatedly as long as the given
returns
Discards results.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Discards results.
- Inhertied from
- Monad
Implicitly added by genTemporalForEitherT
Races the evaluation of two fibers that returns the Outcome of the
winner. The winner of the race is considered to be the first fiber that
completes with an outcome. The loser of the race is canceled before
returning.
winner. The winner of the race is considered to be the first fiber that
completes with an outcome. The loser of the race is canceled before
returning.
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by genTemporalForEitherT
Alias for productR.
- Inhertied from
- Apply
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by genTemporalForEitherT
Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.unzip(List((1,2), (3, 4)))
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
- Inhertied from
- Functor
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by genTemporalForEitherT
Handle any error, by mapping it to an
A
value.- See also
- handleErrorWith to map to an
F[A]
value instead of simply anA
value.recover to only recover from certain errors. - Inhertied from
- ApplicativeError
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by genTemporalForEitherT
Replaces the
A
value in F[A]
with the supplied value.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
}}}
res0: List[String] = List(hello, hello, hello)
}}}
- Inhertied from
- Functor
def attemptNarrow[EE <: Throwable, A](fa: F[A])(tag: ClassTag[EE], ev: EE <:< E): F[Either[EE, A]]
Implicitly added by genTemporalForEitherT
Similar to attempt, but it only handles errors of type
EE
.- Inhertied from
- ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by genTemporalForEitherT
Convert from scala.Option
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int]
, "Empty")
res1: scala.Either[String, Int] = Left(Empty)
}}}
res1: scala.Either[String, Int] = Left(Empty)
}}}
- Inhertied from
- ApplicativeError
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by genTemporalForEitherT
Convert from scala.Either
Example:
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit]
.fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromEither(Left(()))
res1: scala.Option[Nothing] = None
}}}
res1: scala.Option[Nothing] = None
}}}
- Inhertied from
- ApplicativeError
Implicitly added by genTemporalForEitherT
Specifies an effect that is always invoked after evaluation of
completes, regardless of the outcome.
fa
completes, regardless of the outcome.
- Value Params
- fa
-
The effect that is run after
fin
is registered. - fin
-
The effect to run in the event of a cancellation or error.
- See also
- guaranteeCase for a more powerful variantOutcome for the various outcomes of evaluation
- Inhertied from
- MonadCancel
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by genTemporalForEitherT
- Inhertied from
- FlatMap
def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by genTemporalForEitherT
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.acquire
is uncancelable.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action
- release
-
the lifecycle release action which depends on the outcome of
use
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- See also
- bracketFull for a more powerful variantResource for a composable datatype encoding of effectful lifecycles
- Inhertied from
- MonadCancel
@noop
def whileM[G <: ([_$2] =>> Any), A](p: F[Boolean])(body: => F[A])(G: Alternative[G]): F[G[A]]
Implicitly added by genTemporalForEitherT
Execute an action repeatedly as long as the given
returns
Collects the results into an arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Collects the results into an arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by genTemporalForEitherT
This repeats an F until we get defined values. This can be useful
for polling type operations on State (or RNG) Monads, or in effect
monads.
for polling type operations on State (or RNG) Monads, or in effect
monads.
- Inhertied from
- FlatMap
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by genTemporalForEitherT
Tuple the values in fa with the result of applying a function
with the value
with the value
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
}}}
res0: Option[(Int, String)] = Some((42,42))
}}}
- Inhertied from
- Functor
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by genTemporalForEitherT
Simulates an if/else-if/else in the context of an F. It evaluates conditions until
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
{{{
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
- See also
- See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inhertied from
- Monad
Implicitly added by genTemporalForEitherT
Registers a finalizer that is invoked if cancellation is observed
during the evaluation of
without encountering a cancellation, the finalizer is unregistered
before proceeding.
during the evaluation of
fa
. If the evaluation of fa
completeswithout encountering a cancellation, the finalizer is unregistered
before proceeding.
During finalization, all actively registered finalizers are run exactly
once. The order by which finalizers are run is dictated by nesting:
innermost finalizers are run before outermost finalizers. For example,
in the following program, the finalizer
once. The order by which finalizers are run is dictated by nesting:
innermost finalizers are run before outermost finalizers. For example,
in the following program, the finalizer
f1
is run before the finalizerf2
:{{{
F.onCancel(F.onCancel(F.canceled, f1), f2)
}}}
If a finalizer throws an error during evaluation, the error is suppressed,
and implementations may choose to report it via a side channel. Finalizers
are always uncancelable, so cannot otherwise be interrupted.
and implementations may choose to report it via a side channel. Finalizers
are always uncancelable, so cannot otherwise be interrupted.
- Value Params
- fa
-
The effect that is evaluated after
fin
is registered. - fin
-
The finalizer to register before evaluating
fa
.
- Inhertied from
- MonadCancel
def point[A](a: A): F[A]
Implicitly added by genTemporalForEitherT
point
lifts any value into a Monoidal Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> InvariantMonoidal[Option]
.point(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- InvariantMonoidal
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by genTemporalForEitherT
Similar to map2 but uses Eval to allow for laziness in the
argument. This can allow for "short-circuiting" of computations.
F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
map2Eval
does not short-circuitcomputations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example,
but
result of
that the result of
x.map2(bomb)(_ + _)
would result in an error,but
map2Eval
"short-circuits" the computation. x
is None
and thus theresult of
bomb
doesn't even need to be evaluated in order to determinethat the result of
map2Eval
should be None
.{{{
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
- Inhertied from
- Apply
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by genTemporalForEitherT
Convert from cats.data.Validated
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit]
.fromValidated(1.valid[Unit]
)
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromValidated(().invalid[Int]
)
res1: scala.Option[Int] = None
}}}
res1: scala.Option[Int] = None
}}}
- Inhertied from
- ApplicativeError
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForEitherT
Execute an action repeatedly until its result fails to satisfy the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
def raiseError[A](e: E): F[A]
Implicitly added by genTemporalForEitherT
Lift an error into the
F
context.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A]
= Either[String, A]
scala> divide[ErrorOr]
(6, 3)
res0: ErrorOr[Int] = Right(2)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr]
(6, 0)
res1: ErrorOr[Int] = Left(division by zero)
}}}
res1: ErrorOr[Int] = Left(division by zero)
}}}
- Inhertied from
- ApplicativeError
def fromTry[A](t: Try[A])(ev: Throwable <:< E): F[A]
Implicitly added by genTemporalForEitherT
If the error type is Throwable, we can convert from a scala.util.Try
- Inhertied from
- ApplicativeError
def composeFunctor[G <: ([_$3] =>> Any)](evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by genTemporalForEitherT
Compose Invariant
using F's
F[_]
and Functor G[_]
then produce Invariant[F[G[_]]]
using F's
imap
and G's map
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def composeApply[G <: ([_$2] =>> Any)](evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by genTemporalForEitherT
- Inhertied from
- InvariantSemigroupal
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by genTemporalForEitherT
Recover from certain errors by mapping them to an
F[A]
value.- See also
- handleErrorWith to handle any/all errors.recover to recover from certain errors by mapping them to
A
values. - Inhertied from
- ApplicativeError
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by genTemporalForEitherT
"flatten" a nested
F
of F
structure into a single-layer F
structure.This is also commonly called
join
.Example:
{{{
scala> import cats.Eval
scala> import cats.implicits._
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]
] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
- Inhertied from
- FlatMap
def untilM[G <: ([_$4] =>> Any), A](f: F[A])(cond: => F[Boolean])(G: Alternative[G]): F[G[A]]
Implicitly added by genTemporalForEitherT
Execute an action repeatedly until the
The condition is evaluated after the loop body. Collects results into an
arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
condition returns true
.The condition is evaluated after the loop body. Collects results into an
arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
def unit: F[Unit]
Implicitly added by genTemporalForEitherT
Returns an
F[Unit]
value, equivalent with pure(())
.A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a
returned reference (e.g. it can be a
val
).Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.unit
res0: Option[Unit] = Some(())
}}}
res0: Option[Unit] = Some(())
}}}
- Inhertied from
- Applicative
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by genTemporalForEitherT
Execute an action repeatedly until the
The condition is evaluated after the loop body. Discards results.
Boolean
condition returns true
.The condition is evaluated after the loop body. Discards results.
- Inhertied from
- Monad
Implicitly added by genTemporalForEitherT
The child fiber is canceled in two cases: either the resource goes out
of scope or the parent fiber is cancelled. If the child fiber terminates
before one of these cases occurs, then cancellation is a no-op. This
avoids fiber leaks because the child fiber is always canceled before
the parent fiber drops the reference to it.
of scope or the parent fiber is cancelled. If the child fiber terminates
before one of these cases occurs, then cancellation is a no-op. This
avoids fiber leaks because the child fiber is always canceled before
the parent fiber drops the reference to it.
{{{
// Starts a fiber that continously prints "A".
// After 10 seconds, the resource scope exits so the fiber is canceled.
F.background(F.delay(println("A")).foreverM).use { _ =>
F.sleep(10.seconds)
}
// After 10 seconds, the resource scope exits so the fiber is canceled.
F.background(F.delay(println("A")).foreverM).use { _ =>
F.sleep(10.seconds)
}
}}}
- Value Params
- fa
-
the effect for the spawned fiber
- Inhertied from
- GenSpawn
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by genTemporalForEitherT
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the left.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
- Inhertied from
- Functor
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by genTemporalForEitherT
Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.- See also
- handleError to handle any error by simply mapping it to an
A
value instead of anF[A]
.recoverWith to recover from only certain errors. - Inhertied from
- ApplicativeError
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by genTemporalForEitherT
Apply a monadic function and discard the result while keeping the effect.
{{{
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
- Inhertied from
- FlatMap
Implicitly added by genTemporalForEitherT
Masks cancellation on the current fiber. The argument to
Polling causes a fiber to unmask within a masked region so that
cancellation can be observed again.
body
of typePoll[F]
is a natural transformation F ~> F
that enables polling.Polling causes a fiber to unmask within a masked region so that
cancellation can be observed again.
In the following example, cancellation can be observed only within
and nowhere else:
fb
and nowhere else:
{{{
F.uncancelable { poll =>
fa *> poll(fb) *> fc
}
fa *> poll(fb) *> fc
}
}}}
If a fiber is canceled while it is masked, the cancellation is suppressed
for as long as the fiber remains masked. Whenever the fiber is completely
unmasked again, the cancellation will be respected.
for as long as the fiber remains masked. Whenever the fiber is completely
unmasked again, the cancellation will be respected.
Masks can also be stacked or nested within each other. If multiple masks
are active, all masks must be undone so that cancellation can be observed.
In order to completely unmask within a multi-masked region, the poll
corresponding to each mask must be applied, innermost-first.
are active, all masks must be undone so that cancellation can be observed.
In order to completely unmask within a multi-masked region, the poll
corresponding to each mask must be applied, innermost-first.
{{{
F.uncancelable { p1 =>
F.uncancelable { p2 =>
fa *> p2(p1(fb)) *> fc
}
}
F.uncancelable { p2 =>
fa *> p2(p1(fb)) *> fc
}
}
}}}
The following operations are no-ops:
-
Polling in the wrong order
-
Applying the same poll more than once:
poll(poll(fa))
-
Applying a poll bound to one fiber within another fiber
- Inhertied from
- MonadCancel
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by genTemporalForEitherT
Turns a successful value into an error if it does not satisfy a given predicate.
- Inhertied from
- MonadError
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by genTemporalForEitherT
Sequentially compose two actions, discarding any value produced by the second. This variant of
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
- Inhertied from
- FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by genTemporalForEitherT
Sequentially compose two actions, discarding any value produced by the first. This variant of
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
- Inhertied from
- FlatMap
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by genTemporalForEitherT
Execute a callback on certain errors, then rethrow them.
Any non matching error is rethrown as well.
Any non matching error is rethrown as well.
In the following example, only one of the errors is logged,
but they are both rethrown, to be possibly handled by another
layer of the program:
but they are both rethrown, to be possibly handled by another
layer of the program:
{{{
scala> import cats., data., implicits._
scala> import cats., data., implicits._
scala> case class Err(msg: String)
scala> type F[A]
= EitherT[State[String, *]
, Err, A]
scala> val action: PartialFunction[Err, F[Unit]
] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int]
= (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]
) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
- Inhertied from
- ApplicativeError
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Implicitly added by genTemporalForEitherT
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- Inhertied from
- ApplicativeError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by genTemporalForEitherT
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or map
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
Usage of
redeem
subsumes handleError because:{{{
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- ApplicativeError
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by genTemporalForEitherT
Lift a function f to operate on Functors
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
- Inhertied from
- Functor
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by genTemporalForEitherT
Turns a successful value into an error specified by the
error
function if it does not satisfy a given predicate.- Inhertied from
- MonadError
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForEitherT
Apply a monadic function iteratively until its result satisfies
the given predicate and return that result.
the given predicate and return that result.
- Inhertied from
- Monad
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by genTemporalForEitherT
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or bind
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
Usage of
redeemWith
subsumes handleErrorWith because:{{{
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
Usage of
redeemWith
also subsumes flatMap because:{{{
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- bind
-
is the function that gets to transform the source
in case of success - fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- MonadError
def parTraverseN[T <: ([_$3] =>> Any), A, B](n: Int)(ta: T[A])(f: A => F[B])(evidence$2: Traverse[T]): F[T[B]]
Implicitly added by genTemporalForEitherT
Like
Note that the semantics of this operation aim to maximise
fairness: when a spot to execute becomes available, every task
has a chance to claim it, and not only the next
Parallel.parTraverse
, but limits the degree of parallelism.Note that the semantics of this operation aim to maximise
fairness: when a spot to execute becomes available, every task
has a chance to claim it, and not only the next
n
tasks in ta
- Inhertied from
- GenConcurrent
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by genTemporalForEitherT
Given
fa
and n
, apply fa
n
times to construct an F[List[A]]
value.Example:
{{{
scala> import cats.data.State
{{{
scala> import cats.data.State
scala> type Counter[A]
= State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
- Inhertied from
- Applicative
Implicitly added by genTemporalForEitherT
A low-level primitive for starting the concurrent evaluation of a fiber.
Returns a Fiber that can be used to wait for a fiber or cancel it.
Returns a Fiber that can be used to wait for a fiber or cancel it.
start is a cancellation-unsafe function; it is recommended to
use the safer variant, background, to spawn fibers.
use the safer variant, background, to spawn fibers.
- Value Params
- fa
-
the effect for the fiber
- See also
- background for the safer, recommended variant
- Inhertied from
- GenSpawn
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForEitherT
Apply a monadic function iteratively until its result fails
to satisfy the given predicate and return that result.
to satisfy the given predicate and return that result.
- Inhertied from
- Monad
def composeContravariantMonoidal[G <: ([_$3] =>> Any)](evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by genTemporalForEitherT
Compose an
Applicative[F]
and a ContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.byString, Int
scala> val strLength: Order[String] = Order.byString, Int
scala> val stringOrders: List[Order[String]
] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List]
.composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the
//
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
product
of the string order list and the int order list//
p
contains a list of the following orders:// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
- Inhertied from
- Applicative
def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by genTemporalForEitherT
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.If
an exception, the exception is returned.
use
succeeds the returned value B
is returned. If use
returnsan exception, the exception is returned.
acquire
is uncancelable by default, but can be unmasked.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action which can be canceled
- release
-
the lifecycle release action which depends on the outcome of
use
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- Inhertied from
- MonadCancel
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by genTemporalForEitherT
An
This function combines the effects of the
in the order in which they are given.
if-then-else
lifted into the F
context.This function combines the effects of the
fcond
condition and of the two branches,in the order in which they are given.
The value of the result is, depending on the value of the condition,
the value of the first argument, or the value of the second argument.
the value of the first argument, or the value of the second argument.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val b1: Option[Boolean]
= Some(true)
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val b2: Option[Boolean]
= Some(false)
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val b3: Option[Boolean]
= Some(true)
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
}}}
- Inhertied from
- Apply
def catchNonFatal[A](a: => A)(ev: Throwable <:< E): F[A]
Implicitly added by genTemporalForEitherT
Often E is Throwable. Here we try to call pure or catch
and raise.
and raise.
- Inhertied from
- ApplicativeError
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by genTemporalForEitherT
Lifts
if
to FunctorExample:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
}}}
res0: List[Int] = List(1, 0, 0)
}}}
- Inhertied from
- Functor
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by genTemporalForEitherT
Similar to attempt, but wraps the result in a data.EitherT for
convenience.
convenience.
- Inhertied from
- ApplicativeError
Implicitly added by genTemporalForEitherT
An effect that requests self-cancellation on the current fiber.
In the following example, the fiber requests self-cancellation in a masked
region, so cancellation is suppressed until the fiber is completely
unmasked.
region, so cancellation is suppressed until the fiber is completely
unmasked.
fa
will run but fb
will not.{{{
F.uncancelable { _ =>
F.canceled *> fa
} *> fb
F.canceled *> fa
} *> fb
}}}
- Inhertied from
- MonadCancel
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by genTemporalForEitherT
Returns the given argument (mapped to Unit) if
unit lifted into F.
cond
is true
, otherwise,unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
res0: List[Unit] = List((), (), ())
scala> Applicative[List]
.whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
res1: List[Unit] = List(())
scala> Applicative[List]
.whenA(true)(List.empty[Int]
)
res2: List[Unit] = List()
res2: List[Unit] = List()
scala> Applicative[List]
.whenA(false)(List.empty[Int]
)
res3: List[Unit] = List(())
}}}
res3: List[Unit] = List(())
}}}
- Inhertied from
- Applicative
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by genTemporalForEitherT
iterateForeverM is almost exclusively useful for effect types. For instance,
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
- Inhertied from
- FlatMap
Implicitly added by genTemporalForEitherT
Like
Parallel.parSequence
, but limits the degree of parallelism.- Inhertied from
- GenConcurrent
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by genTemporalForEitherT
Like an infinite loop of >> calls. This is most useful effect loops
that you want to run forever in for instance a server.
that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing]
.
Be careful using this.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
- Inhertied from
- FlatMap
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by genTemporalForEitherT
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a
implemented as a type cast. It could be implemented as
according to the functor laws, that should be equal to
cast is often much more performant.
See this example
of
equality this can result in a
ClassCastException
, because it isimplemented as a type cast. It could be implemented as
map(identity)
, butaccording to the functor laws, that should be equal to
fa
, and a typecast is often much more performant.
See this example
of
widen
creating a ClassCastException
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
- Inhertied from
- Functor
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by genTemporalForEitherT
- Inhertied from
- ApplyArityFunctions
def catchNonFatalEval[A](a: Eval[A])(ev: Throwable <:< E): F[A]
Implicitly added by genTemporalForEitherT
Often E is Throwable. Here we try to call pure or catch
and raise
and raise
- Inhertied from
- ApplicativeError
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by genTemporalForEitherT
Handle errors by turning them into scala.util.Either values.
If there is no error, then an
scala.util.Right
value will be returned instead.All non-fatal errors should be handled by this method.
- Inhertied from
- ApplicativeError
Implicitly added by genTemporalForEitherT
Introduces a fairness boundary that yields control back to the scheduler
of the runtime system. This allows the carrier thread to resume execution
of another waiting fiber.
of the runtime system. This allows the carrier thread to resume execution
of another waiting fiber.
Note that
have the liberty to interpret this method to their liking as long as it
obeys the respective laws. For example, a lawful, but atypical,
implementation of this function is
boundary is a no-op.
cede
is merely a hint to the runtime system; implementationshave the liberty to interpret this method to their liking as long as it
obeys the respective laws. For example, a lawful, but atypical,
implementation of this function is
F.unit
, in which case the fairnessboundary is a no-op.
- Inhertied from
- GenSpawn
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by genTemporalForEitherT
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in
the implementing type already had a built-in
.map
method.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val m: Map[Int, String]
= Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
- Inhertied from
- Functor
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by genTemporalForEitherT
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the right.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
- Inhertied from
- Functor
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by genTemporalForEitherT
Keeps calling
f
until a scala.util.Right[B]
is returned.Based on Phil Freeman's
Stack Safety for Free.
Stack Safety for Free.
Implementations of this method should use constant stack space relative to
f
.- Inhertied from
- FlatMap
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by genTemporalForEitherT
Inverse of
attempt
Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]
] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]
] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by genTemporalForEitherT
Returns the given argument (mapped to Unit) if
otherwise, unit lifted into F.
cond
is false
,otherwise, unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
res0: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
res1: List[Unit] = List((), (), ())
scala> Applicative[List]
.unlessA(true)(List.empty[Int]
)
res2: List[Unit] = List(())
res2: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List.empty[Int]
)
res3: List[Unit] = List()
}}}
res3: List[Unit] = List()
}}}
- Inhertied from
- Applicative
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by genTemporalForEitherT
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into
then recovers the original value or error back into
F
.Note that if the effect returned by
f
fails, the resulting effect will fail too.Alias for
fa.attempt.flatTap(f).rethrow
for convenience.Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]
): Try[String]
= result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int]
= Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int]
= Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def void[A](fa: F[A]): F[Unit]
Implicitly added by genTemporalForEitherT
Empty the fa of the values, preserving the structure
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.void(List(1,2,3))
res0: List[Unit] = List((), (), ())
}}}
res0: List[Unit] = List((), (), ())
}}}
- Inhertied from
- Functor
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by genTemporalForEitherT
Alias for productL.
- Inhertied from
- Apply
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by genTemporalForEitherT
if
lifted into monad.- Inhertied from
- FlatMap
Implicitly added by genTemporalForEitherT
Specifies an effect that is always invoked after evaluation of
completes, but depends on the outcome.
fa
completes, but depends on the outcome.
- Value Params
- fa
-
The effect that is run after
fin
is registered. - fin
-
A function that returns the effect to run based on the
outcome.
- See also
- bracketCase for a more powerful variantOutcome for the various outcomes of evaluation
- Inhertied from
- MonadCancel
def compose[G <: ([_$2] =>> Any)](evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by genTemporalForEitherT
Compose an
Applicative[F]
and an Applicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Applicative[List]
.compose[Option]
scala> alo.pure(3)
res0: List[Option[Int] ] = List(Some(3))
res0: List[Option[Int] ] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Applicative
def compose[G <: ([_$2] =>> Any)](evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by genTemporalForEitherT
Compose Invariant
F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def compose[G <: ([_$3] =>> Any)](evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by genTemporalForEitherT
Compose an
Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Apply[List]
.compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Apply
def compose[G <: ([_$6] =>> Any)](evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by genTemporalForEitherT
- Inhertied from
- Functor
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForEitherT
Execute an action repeatedly until its result satisfies the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
Implicitly added by genTemporalForEitherT
Races the evaluation of two fibers and returns the Outcome of both. If
the race is canceled before one or both participants complete, then
then whichever ones are incomplete are canceled.
the race is canceled before one or both participants complete, then
then whichever ones are incomplete are canceled.
Implicitly added by genTemporalForEitherT
Races the evaluation of two fibers that returns the result of the winner,
except in the case of cancellation.
except in the case of cancellation.
The semantics of race are described by the following rules:
-
If the winner completes with Succeeded, the race returns the
successful value. The loser is canceled before returning. -
If the winner completes with Errored, the race raises the error.
The loser is canceled before returning. -
If the winner completes with Canceled, the race returns the
result of the loser, consistent with the first two rules. -
If both the winner and loser complete with Canceled, the race
is canceled. -
If the race is masked and is canceled because both participants
canceled, the fiber will block indefinitely.
- Value Params
- fa
-
the effect for the first racing fiber
- fb
-
the effect for the second racing fiber
- See also
- raceOutcome for a variant that returns the outcome of the winner.
- Inhertied from
- GenSpawn
Implicitly added by genTemporalForEitherT
A non-terminating effect that never completes, which causes a fiber to
semantically block indefinitely. This is the purely functional,
asynchronous equivalent of an infinite while loop in Java, but no
native threads are blocked.
semantically block indefinitely. This is the purely functional,
asynchronous equivalent of an infinite while loop in Java, but no
native threads are blocked.
A fiber that is suspended in never can be canceled if it is
completely unmasked before it suspends:
completely unmasked before it suspends:
{{{
// ignoring race conditions between
F.never.start.flatMap(_.cancel) <-> F.unit
start
and cancel
F.never.start.flatMap(_.cancel) <-> F.unit
}}}
However, if the fiber is masked, cancellers will be semantically blocked
forever:
forever:
{{{
// ignoring race conditions between
F.uncancelable(_ => F.never).start.flatMap(_.cancel) <-> F.never
start
and cancel
F.uncancelable(_ => F.never).start.flatMap(_.cancel) <-> F.never
}}}
- Inhertied from
- GenSpawn
Implicitly added by genTemporalForEitherT
Races the evaluation of two fibers and returns the result of both.
The following rules describe the semantics of both:
-
If the winner completes with Succeeded, the race waits for the
loser to complete. -
If the winner completes with Errored, the race raises the error.
The loser is canceled. -
If the winner completes with Canceled, the loser and the race
are canceled as well. -
If the loser completes with Succeeded, the race returns the
successful value of both fibers. -
If the loser completes with Errored, the race returns the error.
-
If the loser completes with Canceled, the race is canceled.
-
If the race is canceled before one or both participants complete,
then whichever ones are incomplete are canceled. -
If the race is masked and is canceled because one or both
participants canceled, the fiber will block indefinitely.
- Value Params
- fa
-
the effect for the first racing fiber
- fb
-
the effect for the second racing fiber
- See also
- Inhertied from
- GenSpawn
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by genTemporalForEitherT
Recover from certain errors by mapping them to an
A
value.- See also
- handleError to handle any/all errors.recoverWith to recover from certain errors by mapping them to
F[A]
values. - Inhertied from
- ApplicativeError
Implicitly added by genTemporalForEitherT
Analogous to productR, but suppresses short-circuiting behavior
except for cancellation.
except for cancellation.
- Inhertied from
- MonadCancel
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by genTemporalForEitherT
Alias for ap.
- Inhertied from
- Apply
Implicitly added by genTemporalForEitherT
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.acquire
is uncancelable.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action
- release
-
the lifecycle release action
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- See also
- bracketCase for a more powerful variantResource for a composable datatype encoding of effectful lifecycles
- Inhertied from
- MonadCancel
def pure[A](x: A): F[A]
Implicitly added by genTemporalForEitherT
pure
lifts any value into the Applicative Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.pure(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- Applicative
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by genTemporalForKleisli
Pair the result of function application with
A
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
}}}
res0: Option[(String, Int)] = Some((42,42))
}}}
- Inhertied from
- Functor
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by genTemporalForKleisli
Pair
A
with the result of function application.Example:
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
- Inhertied from
- FlatMap
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by genTemporalForKleisli
Execute an action repeatedly as long as the given
returns
Discards results.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Discards results.
- Inhertied from
- Monad
Implicitly added by genTemporalForKleisli
Races the evaluation of two fibers that returns the Outcome of the
winner. The winner of the race is considered to be the first fiber that
completes with an outcome. The loser of the race is canceled before
returning.
winner. The winner of the race is considered to be the first fiber that
completes with an outcome. The loser of the race is canceled before
returning.
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by genTemporalForKleisli
Alias for productR.
- Inhertied from
- Apply
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by genTemporalForKleisli
Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.unzip(List((1,2), (3, 4)))
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
- Inhertied from
- Functor
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by genTemporalForKleisli
Handle any error, by mapping it to an
A
value.- See also
- handleErrorWith to map to an
F[A]
value instead of simply anA
value.recover to only recover from certain errors. - Inhertied from
- ApplicativeError
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by genTemporalForKleisli
Replaces the
A
value in F[A]
with the supplied value.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
}}}
res0: List[String] = List(hello, hello, hello)
}}}
- Inhertied from
- Functor
def attemptNarrow[EE <: Throwable, A](fa: F[A])(tag: ClassTag[EE], ev: EE <:< E): F[Either[EE, A]]
Implicitly added by genTemporalForKleisli
Similar to attempt, but it only handles errors of type
EE
.- Inhertied from
- ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by genTemporalForKleisli
Convert from scala.Option
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int]
, "Empty")
res1: scala.Either[String, Int] = Left(Empty)
}}}
res1: scala.Either[String, Int] = Left(Empty)
}}}
- Inhertied from
- ApplicativeError
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by genTemporalForKleisli
Convert from scala.Either
Example:
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit]
.fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromEither(Left(()))
res1: scala.Option[Nothing] = None
}}}
res1: scala.Option[Nothing] = None
}}}
- Inhertied from
- ApplicativeError
Implicitly added by genTemporalForKleisli
Specifies an effect that is always invoked after evaluation of
completes, regardless of the outcome.
fa
completes, regardless of the outcome.
- Value Params
- fa
-
The effect that is run after
fin
is registered. - fin
-
The effect to run in the event of a cancellation or error.
- See also
- guaranteeCase for a more powerful variantOutcome for the various outcomes of evaluation
- Inhertied from
- MonadCancel
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by genTemporalForKleisli
- Inhertied from
- FlatMap
def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by genTemporalForKleisli
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.acquire
is uncancelable.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action
- release
-
the lifecycle release action which depends on the outcome of
use
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- See also
- bracketFull for a more powerful variantResource for a composable datatype encoding of effectful lifecycles
- Inhertied from
- MonadCancel
@noop
def whileM[G <: ([_$2] =>> Any), A](p: F[Boolean])(body: => F[A])(G: Alternative[G]): F[G[A]]
Implicitly added by genTemporalForKleisli
Execute an action repeatedly as long as the given
returns
Collects the results into an arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Collects the results into an arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by genTemporalForKleisli
This repeats an F until we get defined values. This can be useful
for polling type operations on State (or RNG) Monads, or in effect
monads.
for polling type operations on State (or RNG) Monads, or in effect
monads.
- Inhertied from
- FlatMap
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by genTemporalForKleisli
Tuple the values in fa with the result of applying a function
with the value
with the value
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
}}}
res0: Option[(Int, String)] = Some((42,42))
}}}
- Inhertied from
- Functor
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by genTemporalForKleisli
Simulates an if/else-if/else in the context of an F. It evaluates conditions until
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
{{{
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
- See also
- See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inhertied from
- Monad
Implicitly added by genTemporalForKleisli
Registers a finalizer that is invoked if cancellation is observed
during the evaluation of
without encountering a cancellation, the finalizer is unregistered
before proceeding.
during the evaluation of
fa
. If the evaluation of fa
completeswithout encountering a cancellation, the finalizer is unregistered
before proceeding.
During finalization, all actively registered finalizers are run exactly
once. The order by which finalizers are run is dictated by nesting:
innermost finalizers are run before outermost finalizers. For example,
in the following program, the finalizer
once. The order by which finalizers are run is dictated by nesting:
innermost finalizers are run before outermost finalizers. For example,
in the following program, the finalizer
f1
is run before the finalizerf2
:{{{
F.onCancel(F.onCancel(F.canceled, f1), f2)
}}}
If a finalizer throws an error during evaluation, the error is suppressed,
and implementations may choose to report it via a side channel. Finalizers
are always uncancelable, so cannot otherwise be interrupted.
and implementations may choose to report it via a side channel. Finalizers
are always uncancelable, so cannot otherwise be interrupted.
- Value Params
- fa
-
The effect that is evaluated after
fin
is registered. - fin
-
The finalizer to register before evaluating
fa
.
- Inhertied from
- MonadCancel
def point[A](a: A): F[A]
Implicitly added by genTemporalForKleisli
point
lifts any value into a Monoidal Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> InvariantMonoidal[Option]
.point(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- InvariantMonoidal
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by genTemporalForKleisli
Similar to map2 but uses Eval to allow for laziness in the
argument. This can allow for "short-circuiting" of computations.
F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
map2Eval
does not short-circuitcomputations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example,
but
result of
that the result of
x.map2(bomb)(_ + _)
would result in an error,but
map2Eval
"short-circuits" the computation. x
is None
and thus theresult of
bomb
doesn't even need to be evaluated in order to determinethat the result of
map2Eval
should be None
.{{{
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
- Inhertied from
- Apply
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by genTemporalForKleisli
Convert from cats.data.Validated
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit]
.fromValidated(1.valid[Unit]
)
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromValidated(().invalid[Int]
)
res1: scala.Option[Int] = None
}}}
res1: scala.Option[Int] = None
}}}
- Inhertied from
- ApplicativeError
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForKleisli
Execute an action repeatedly until its result fails to satisfy the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
def raiseError[A](e: E): F[A]
Implicitly added by genTemporalForKleisli
Lift an error into the
F
context.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A]
= Either[String, A]
scala> divide[ErrorOr]
(6, 3)
res0: ErrorOr[Int] = Right(2)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr]
(6, 0)
res1: ErrorOr[Int] = Left(division by zero)
}}}
res1: ErrorOr[Int] = Left(division by zero)
}}}
- Inhertied from
- ApplicativeError
def fromTry[A](t: Try[A])(ev: Throwable <:< E): F[A]
Implicitly added by genTemporalForKleisli
If the error type is Throwable, we can convert from a scala.util.Try
- Inhertied from
- ApplicativeError
def composeFunctor[G <: ([_$3] =>> Any)](evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by genTemporalForKleisli
Compose Invariant
using F's
F[_]
and Functor G[_]
then produce Invariant[F[G[_]]]
using F's
imap
and G's map
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def composeApply[G <: ([_$2] =>> Any)](evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by genTemporalForKleisli
- Inhertied from
- InvariantSemigroupal
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by genTemporalForKleisli
Recover from certain errors by mapping them to an
F[A]
value.- See also
- handleErrorWith to handle any/all errors.recover to recover from certain errors by mapping them to
A
values. - Inhertied from
- ApplicativeError
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by genTemporalForKleisli
"flatten" a nested
F
of F
structure into a single-layer F
structure.This is also commonly called
join
.Example:
{{{
scala> import cats.Eval
scala> import cats.implicits._
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]
] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
- Inhertied from
- FlatMap
def untilM[G <: ([_$4] =>> Any), A](f: F[A])(cond: => F[Boolean])(G: Alternative[G]): F[G[A]]
Implicitly added by genTemporalForKleisli
Execute an action repeatedly until the
The condition is evaluated after the loop body. Collects results into an
arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
condition returns true
.The condition is evaluated after the loop body. Collects results into an
arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
def unit: F[Unit]
Implicitly added by genTemporalForKleisli
Returns an
F[Unit]
value, equivalent with pure(())
.A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a
returned reference (e.g. it can be a
val
).Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.unit
res0: Option[Unit] = Some(())
}}}
res0: Option[Unit] = Some(())
}}}
- Inhertied from
- Applicative
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by genTemporalForKleisli
Execute an action repeatedly until the
The condition is evaluated after the loop body. Discards results.
Boolean
condition returns true
.The condition is evaluated after the loop body. Discards results.
- Inhertied from
- Monad
Implicitly added by genTemporalForKleisli
The child fiber is canceled in two cases: either the resource goes out
of scope or the parent fiber is cancelled. If the child fiber terminates
before one of these cases occurs, then cancellation is a no-op. This
avoids fiber leaks because the child fiber is always canceled before
the parent fiber drops the reference to it.
of scope or the parent fiber is cancelled. If the child fiber terminates
before one of these cases occurs, then cancellation is a no-op. This
avoids fiber leaks because the child fiber is always canceled before
the parent fiber drops the reference to it.
{{{
// Starts a fiber that continously prints "A".
// After 10 seconds, the resource scope exits so the fiber is canceled.
F.background(F.delay(println("A")).foreverM).use { _ =>
F.sleep(10.seconds)
}
// After 10 seconds, the resource scope exits so the fiber is canceled.
F.background(F.delay(println("A")).foreverM).use { _ =>
F.sleep(10.seconds)
}
}}}
- Value Params
- fa
-
the effect for the spawned fiber
- Inhertied from
- GenSpawn
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by genTemporalForKleisli
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the left.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
- Inhertied from
- Functor
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by genTemporalForKleisli
Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.- See also
- handleError to handle any error by simply mapping it to an
A
value instead of anF[A]
.recoverWith to recover from only certain errors. - Inhertied from
- ApplicativeError
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by genTemporalForKleisli
Apply a monadic function and discard the result while keeping the effect.
{{{
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
- Inhertied from
- FlatMap
Implicitly added by genTemporalForKleisli
Masks cancellation on the current fiber. The argument to
Polling causes a fiber to unmask within a masked region so that
cancellation can be observed again.
body
of typePoll[F]
is a natural transformation F ~> F
that enables polling.Polling causes a fiber to unmask within a masked region so that
cancellation can be observed again.
In the following example, cancellation can be observed only within
and nowhere else:
fb
and nowhere else:
{{{
F.uncancelable { poll =>
fa *> poll(fb) *> fc
}
fa *> poll(fb) *> fc
}
}}}
If a fiber is canceled while it is masked, the cancellation is suppressed
for as long as the fiber remains masked. Whenever the fiber is completely
unmasked again, the cancellation will be respected.
for as long as the fiber remains masked. Whenever the fiber is completely
unmasked again, the cancellation will be respected.
Masks can also be stacked or nested within each other. If multiple masks
are active, all masks must be undone so that cancellation can be observed.
In order to completely unmask within a multi-masked region, the poll
corresponding to each mask must be applied, innermost-first.
are active, all masks must be undone so that cancellation can be observed.
In order to completely unmask within a multi-masked region, the poll
corresponding to each mask must be applied, innermost-first.
{{{
F.uncancelable { p1 =>
F.uncancelable { p2 =>
fa *> p2(p1(fb)) *> fc
}
}
F.uncancelable { p2 =>
fa *> p2(p1(fb)) *> fc
}
}
}}}
The following operations are no-ops:
-
Polling in the wrong order
-
Applying the same poll more than once:
poll(poll(fa))
-
Applying a poll bound to one fiber within another fiber
- Inhertied from
- MonadCancel
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by genTemporalForKleisli
Turns a successful value into an error if it does not satisfy a given predicate.
- Inhertied from
- MonadError
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by genTemporalForKleisli
Sequentially compose two actions, discarding any value produced by the second. This variant of
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
- Inhertied from
- FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by genTemporalForKleisli
Sequentially compose two actions, discarding any value produced by the first. This variant of
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
- Inhertied from
- FlatMap
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by genTemporalForKleisli
Execute a callback on certain errors, then rethrow them.
Any non matching error is rethrown as well.
Any non matching error is rethrown as well.
In the following example, only one of the errors is logged,
but they are both rethrown, to be possibly handled by another
layer of the program:
but they are both rethrown, to be possibly handled by another
layer of the program:
{{{
scala> import cats., data., implicits._
scala> import cats., data., implicits._
scala> case class Err(msg: String)
scala> type F[A]
= EitherT[State[String, *]
, Err, A]
scala> val action: PartialFunction[Err, F[Unit]
] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int]
= (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]
) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
- Inhertied from
- ApplicativeError
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Implicitly added by genTemporalForKleisli
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- Inhertied from
- ApplicativeError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by genTemporalForKleisli
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or map
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
Usage of
redeem
subsumes handleError because:{{{
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- ApplicativeError
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by genTemporalForKleisli
Lift a function f to operate on Functors
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
- Inhertied from
- Functor
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by genTemporalForKleisli
Turns a successful value into an error specified by the
error
function if it does not satisfy a given predicate.- Inhertied from
- MonadError
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForKleisli
Apply a monadic function iteratively until its result satisfies
the given predicate and return that result.
the given predicate and return that result.
- Inhertied from
- Monad
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by genTemporalForKleisli
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or bind
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
Usage of
redeemWith
subsumes handleErrorWith because:{{{
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
Usage of
redeemWith
also subsumes flatMap because:{{{
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- bind
-
is the function that gets to transform the source
in case of success - fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- MonadError
def parTraverseN[T <: ([_$3] =>> Any), A, B](n: Int)(ta: T[A])(f: A => F[B])(evidence$2: Traverse[T]): F[T[B]]
Implicitly added by genTemporalForKleisli
Like
Note that the semantics of this operation aim to maximise
fairness: when a spot to execute becomes available, every task
has a chance to claim it, and not only the next
Parallel.parTraverse
, but limits the degree of parallelism.Note that the semantics of this operation aim to maximise
fairness: when a spot to execute becomes available, every task
has a chance to claim it, and not only the next
n
tasks in ta
- Inhertied from
- GenConcurrent
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by genTemporalForKleisli
Given
fa
and n
, apply fa
n
times to construct an F[List[A]]
value.Example:
{{{
scala> import cats.data.State
{{{
scala> import cats.data.State
scala> type Counter[A]
= State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
- Inhertied from
- Applicative
Implicitly added by genTemporalForKleisli
A low-level primitive for starting the concurrent evaluation of a fiber.
Returns a Fiber that can be used to wait for a fiber or cancel it.
Returns a Fiber that can be used to wait for a fiber or cancel it.
start is a cancellation-unsafe function; it is recommended to
use the safer variant, background, to spawn fibers.
use the safer variant, background, to spawn fibers.
- Value Params
- fa
-
the effect for the fiber
- See also
- background for the safer, recommended variant
- Inhertied from
- GenSpawn
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForKleisli
Apply a monadic function iteratively until its result fails
to satisfy the given predicate and return that result.
to satisfy the given predicate and return that result.
- Inhertied from
- Monad
def composeContravariantMonoidal[G <: ([_$3] =>> Any)](evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by genTemporalForKleisli
Compose an
Applicative[F]
and a ContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.byString, Int
scala> val strLength: Order[String] = Order.byString, Int
scala> val stringOrders: List[Order[String]
] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List]
.composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the
//
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
product
of the string order list and the int order list//
p
contains a list of the following orders:// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
- Inhertied from
- Applicative
def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by genTemporalForKleisli
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.If
an exception, the exception is returned.
use
succeeds the returned value B
is returned. If use
returnsan exception, the exception is returned.
acquire
is uncancelable by default, but can be unmasked.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action which can be canceled
- release
-
the lifecycle release action which depends on the outcome of
use
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- Inhertied from
- MonadCancel
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by genTemporalForKleisli
An
This function combines the effects of the
in the order in which they are given.
if-then-else
lifted into the F
context.This function combines the effects of the
fcond
condition and of the two branches,in the order in which they are given.
The value of the result is, depending on the value of the condition,
the value of the first argument, or the value of the second argument.
the value of the first argument, or the value of the second argument.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val b1: Option[Boolean]
= Some(true)
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val b2: Option[Boolean]
= Some(false)
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val b3: Option[Boolean]
= Some(true)
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
}}}
- Inhertied from
- Apply
def catchNonFatal[A](a: => A)(ev: Throwable <:< E): F[A]
Implicitly added by genTemporalForKleisli
Often E is Throwable. Here we try to call pure or catch
and raise.
and raise.
- Inhertied from
- ApplicativeError
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by genTemporalForKleisli
Lifts
if
to FunctorExample:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
}}}
res0: List[Int] = List(1, 0, 0)
}}}
- Inhertied from
- Functor
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by genTemporalForKleisli
Similar to attempt, but wraps the result in a data.EitherT for
convenience.
convenience.
- Inhertied from
- ApplicativeError
Implicitly added by genTemporalForKleisli
An effect that requests self-cancellation on the current fiber.
In the following example, the fiber requests self-cancellation in a masked
region, so cancellation is suppressed until the fiber is completely
unmasked.
region, so cancellation is suppressed until the fiber is completely
unmasked.
fa
will run but fb
will not.{{{
F.uncancelable { _ =>
F.canceled *> fa
} *> fb
F.canceled *> fa
} *> fb
}}}
- Inhertied from
- MonadCancel
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by genTemporalForKleisli
Returns the given argument (mapped to Unit) if
unit lifted into F.
cond
is true
, otherwise,unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
res0: List[Unit] = List((), (), ())
scala> Applicative[List]
.whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
res1: List[Unit] = List(())
scala> Applicative[List]
.whenA(true)(List.empty[Int]
)
res2: List[Unit] = List()
res2: List[Unit] = List()
scala> Applicative[List]
.whenA(false)(List.empty[Int]
)
res3: List[Unit] = List(())
}}}
res3: List[Unit] = List(())
}}}
- Inhertied from
- Applicative
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by genTemporalForKleisli
iterateForeverM is almost exclusively useful for effect types. For instance,
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
- Inhertied from
- FlatMap
Implicitly added by genTemporalForKleisli
Like
Parallel.parSequence
, but limits the degree of parallelism.- Inhertied from
- GenConcurrent
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by genTemporalForKleisli
Like an infinite loop of >> calls. This is most useful effect loops
that you want to run forever in for instance a server.
that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing]
.
Be careful using this.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
- Inhertied from
- FlatMap
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by genTemporalForKleisli
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a
implemented as a type cast. It could be implemented as
according to the functor laws, that should be equal to
cast is often much more performant.
See this example
of
equality this can result in a
ClassCastException
, because it isimplemented as a type cast. It could be implemented as
map(identity)
, butaccording to the functor laws, that should be equal to
fa
, and a typecast is often much more performant.
See this example
of
widen
creating a ClassCastException
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
- Inhertied from
- Functor
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by genTemporalForKleisli
- Inhertied from
- ApplyArityFunctions
def catchNonFatalEval[A](a: Eval[A])(ev: Throwable <:< E): F[A]
Implicitly added by genTemporalForKleisli
Often E is Throwable. Here we try to call pure or catch
and raise
and raise
- Inhertied from
- ApplicativeError
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by genTemporalForKleisli
Handle errors by turning them into scala.util.Either values.
If there is no error, then an
scala.util.Right
value will be returned instead.All non-fatal errors should be handled by this method.
- Inhertied from
- ApplicativeError
Implicitly added by genTemporalForKleisli
Introduces a fairness boundary that yields control back to the scheduler
of the runtime system. This allows the carrier thread to resume execution
of another waiting fiber.
of the runtime system. This allows the carrier thread to resume execution
of another waiting fiber.
Note that
have the liberty to interpret this method to their liking as long as it
obeys the respective laws. For example, a lawful, but atypical,
implementation of this function is
boundary is a no-op.
cede
is merely a hint to the runtime system; implementationshave the liberty to interpret this method to their liking as long as it
obeys the respective laws. For example, a lawful, but atypical,
implementation of this function is
F.unit
, in which case the fairnessboundary is a no-op.
- Inhertied from
- GenSpawn
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by genTemporalForKleisli
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in
the implementing type already had a built-in
.map
method.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val m: Map[Int, String]
= Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
- Inhertied from
- Functor
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by genTemporalForKleisli
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the right.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
- Inhertied from
- Functor
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by genTemporalForKleisli
Keeps calling
f
until a scala.util.Right[B]
is returned.Based on Phil Freeman's
Stack Safety for Free.
Stack Safety for Free.
Implementations of this method should use constant stack space relative to
f
.- Inhertied from
- FlatMap
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by genTemporalForKleisli
Inverse of
attempt
Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]
] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]
] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by genTemporalForKleisli
Returns the given argument (mapped to Unit) if
otherwise, unit lifted into F.
cond
is false
,otherwise, unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
res0: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
res1: List[Unit] = List((), (), ())
scala> Applicative[List]
.unlessA(true)(List.empty[Int]
)
res2: List[Unit] = List(())
res2: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List.empty[Int]
)
res3: List[Unit] = List()
}}}
res3: List[Unit] = List()
}}}
- Inhertied from
- Applicative
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by genTemporalForKleisli
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into
then recovers the original value or error back into
F
.Note that if the effect returned by
f
fails, the resulting effect will fail too.Alias for
fa.attempt.flatTap(f).rethrow
for convenience.Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]
): Try[String]
= result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int]
= Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int]
= Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def void[A](fa: F[A]): F[Unit]
Implicitly added by genTemporalForKleisli
Empty the fa of the values, preserving the structure
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.void(List(1,2,3))
res0: List[Unit] = List((), (), ())
}}}
res0: List[Unit] = List((), (), ())
}}}
- Inhertied from
- Functor
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by genTemporalForKleisli
Alias for productL.
- Inhertied from
- Apply
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by genTemporalForKleisli
if
lifted into monad.- Inhertied from
- FlatMap
Implicitly added by genTemporalForKleisli
Specifies an effect that is always invoked after evaluation of
completes, but depends on the outcome.
fa
completes, but depends on the outcome.
- Value Params
- fa
-
The effect that is run after
fin
is registered. - fin
-
A function that returns the effect to run based on the
outcome.
- See also
- bracketCase for a more powerful variantOutcome for the various outcomes of evaluation
- Inhertied from
- MonadCancel
def compose[G <: ([_$2] =>> Any)](evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by genTemporalForKleisli
Compose an
Applicative[F]
and an Applicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Applicative[List]
.compose[Option]
scala> alo.pure(3)
res0: List[Option[Int] ] = List(Some(3))
res0: List[Option[Int] ] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Applicative
def compose[G <: ([_$2] =>> Any)](evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by genTemporalForKleisli
Compose Invariant
F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def compose[G <: ([_$3] =>> Any)](evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by genTemporalForKleisli
Compose an
Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Apply[List]
.compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Apply
def compose[G <: ([_$6] =>> Any)](evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by genTemporalForKleisli
- Inhertied from
- Functor
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by genTemporalForKleisli
Execute an action repeatedly until its result satisfies the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
Implicitly added by genTemporalForKleisli
Races the evaluation of two fibers and returns the Outcome of both. If
the race is canceled before one or both participants complete, then
then whichever ones are incomplete are canceled.
the race is canceled before one or both participants complete, then
then whichever ones are incomplete are canceled.
Implicitly added by genTemporalForKleisli
Races the evaluation of two fibers that returns the result of the winner,
except in the case of cancellation.
except in the case of cancellation.
The semantics of race are described by the following rules:
-
If the winner completes with Succeeded, the race returns the
successful value. The loser is canceled before returning. -
If the winner completes with Errored, the race raises the error.
The loser is canceled before returning. -
If the winner completes with Canceled, the race returns the
result of the loser, consistent with the first two rules. -
If both the winner and loser complete with Canceled, the race
is canceled. -
If the race is masked and is canceled because both participants
canceled, the fiber will block indefinitely.
- Value Params
- fa
-
the effect for the first racing fiber
- fb
-
the effect for the second racing fiber
- See also
- raceOutcome for a variant that returns the outcome of the winner.
- Inhertied from
- GenSpawn
Implicitly added by genTemporalForKleisli
A non-terminating effect that never completes, which causes a fiber to
semantically block indefinitely. This is the purely functional,
asynchronous equivalent of an infinite while loop in Java, but no
native threads are blocked.
semantically block indefinitely. This is the purely functional,
asynchronous equivalent of an infinite while loop in Java, but no
native threads are blocked.
A fiber that is suspended in never can be canceled if it is
completely unmasked before it suspends:
completely unmasked before it suspends:
{{{
// ignoring race conditions between
F.never.start.flatMap(_.cancel) <-> F.unit
start
and cancel
F.never.start.flatMap(_.cancel) <-> F.unit
}}}
However, if the fiber is masked, cancellers will be semantically blocked
forever:
forever:
{{{
// ignoring race conditions between
F.uncancelable(_ => F.never).start.flatMap(_.cancel) <-> F.never
start
and cancel
F.uncancelable(_ => F.never).start.flatMap(_.cancel) <-> F.never
}}}
- Inhertied from
- GenSpawn
Implicitly added by genTemporalForKleisli
Races the evaluation of two fibers and returns the result of both.
The following rules describe the semantics of both:
-
If the winner completes with Succeeded, the race waits for the
loser to complete. -
If the winner completes with Errored, the race raises the error.
The loser is canceled. -
If the winner completes with Canceled, the loser and the race
are canceled as well. -
If the loser completes with Succeeded, the race returns the
successful value of both fibers. -
If the loser completes with Errored, the race returns the error.
-
If the loser completes with Canceled, the race is canceled.
-
If the race is canceled before one or both participants complete,
then whichever ones are incomplete are canceled. -
If the race is masked and is canceled because one or both
participants canceled, the fiber will block indefinitely.
- Value Params
- fa
-
the effect for the first racing fiber
- fb
-
the effect for the second racing fiber
- See also
- Inhertied from
- GenSpawn
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by genTemporalForKleisli
Recover from certain errors by mapping them to an
A
value.- See also
- handleError to handle any/all errors.recoverWith to recover from certain errors by mapping them to
F[A]
values. - Inhertied from
- ApplicativeError
Implicitly added by genTemporalForKleisli
Analogous to productR, but suppresses short-circuiting behavior
except for cancellation.
except for cancellation.
- Inhertied from
- MonadCancel
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by genTemporalForKleisli
Alias for ap.
- Inhertied from
- Apply
Implicitly added by genTemporalForKleisli
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.acquire
is uncancelable.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action
- release
-
the lifecycle release action
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- See also
- bracketCase for a more powerful variantResource for a composable datatype encoding of effectful lifecycles
- Inhertied from
- MonadCancel
def pure[A](x: A): F[A]
Implicitly added by genTemporalForKleisli
pure
lifts any value into the Applicative Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.pure(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- Applicative
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Pair the result of function application with
A
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
}}}
res0: Option[(String, Int)] = Some((42,42))
}}}
- Inhertied from
- Functor
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Pair
A
with the result of function application.Example:
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
- Inhertied from
- FlatMap
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Execute an action repeatedly as long as the given
returns
Discards results.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Discards results.
- Inhertied from
- Monad
Races the evaluation of two fibers that returns the Outcome of the
winner. The winner of the race is considered to be the first fiber that
completes with an outcome. The loser of the race is canceled before
returning.
winner. The winner of the race is considered to be the first fiber that
completes with an outcome. The loser of the race is canceled before
returning.
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.unzip(List((1,2), (3, 4)))
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
- Inhertied from
- Functor
def handleError[A](fa: F[A])(f: E => A): F[A]
Handle any error, by mapping it to an
A
value.- See also
- handleErrorWith to map to an
F[A]
value instead of simply anA
value.recover to only recover from certain errors. - Inhertied from
- ApplicativeError
def as[A, B](fa: F[A], b: B): F[B]
Replaces the
A
value in F[A]
with the supplied value.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
}}}
res0: List[String] = List(hello, hello, hello)
}}}
- Inhertied from
- Functor
override def composeContravariant[G <: ([_$7] =>> Any)](evidence$2: Contravariant[G]): Contravariant[[α] =>> F[G[α]]]
- Definition Classes
- Functor -> Invariant
- Inhertied from
- Functor
def attemptNarrow[EE <: Throwable, A](fa: F[A])(tag: ClassTag[EE], ev: EE <:< E): F[Either[EE, A]]
Similar to attempt, but it only handles errors of type
EE
.- Inhertied from
- ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Convert from scala.Option
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int]
, "Empty")
res1: scala.Either[String, Int] = Left(Empty)
}}}
res1: scala.Either[String, Int] = Left(Empty)
}}}
- Inhertied from
- ApplicativeError
def fromEither[A](x: Either[E, A]): F[A]
Convert from scala.Either
Example:
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit]
.fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromEither(Left(()))
res1: scala.Option[Nothing] = None
}}}
res1: scala.Option[Nothing] = None
}}}
- Inhertied from
- ApplicativeError
Specifies an effect that is always invoked after evaluation of
completes, regardless of the outcome.
fa
completes, regardless of the outcome.
- Value Params
- fa
-
The effect that is run after
fin
is registered. - fin
-
The effect to run in the event of a cancellation or error.
- See also
- guaranteeCase for a more powerful variantOutcome for the various outcomes of evaluation
- Inhertied from
- MonadCancel
def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.acquire
is uncancelable.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action
- release
-
the lifecycle release action which depends on the outcome of
use
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- See also
- bracketFull for a more powerful variantResource for a composable datatype encoding of effectful lifecycles
- Inhertied from
- MonadCancel
@noop
def whileM[G <: ([_$2] =>> Any), A](p: F[Boolean])(body: => F[A])(G: Alternative[G]): F[G[A]]
Execute an action repeatedly as long as the given
returns
Collects the results into an arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Collects the results into an arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
This repeats an F until we get defined values. This can be useful
for polling type operations on State (or RNG) Monads, or in effect
monads.
for polling type operations on State (or RNG) Monads, or in effect
monads.
- Inhertied from
- FlatMap
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Tuple the values in fa with the result of applying a function
with the value
with the value
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
}}}
res0: Option[(Int, String)] = Some((42,42))
}}}
- Inhertied from
- Functor
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Simulates an if/else-if/else in the context of an F. It evaluates conditions until
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
{{{
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
- See also
- See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inhertied from
- Monad
Registers a finalizer that is invoked if cancellation is observed
during the evaluation of
without encountering a cancellation, the finalizer is unregistered
before proceeding.
during the evaluation of
fa
. If the evaluation of fa
completeswithout encountering a cancellation, the finalizer is unregistered
before proceeding.
During finalization, all actively registered finalizers are run exactly
once. The order by which finalizers are run is dictated by nesting:
innermost finalizers are run before outermost finalizers. For example,
in the following program, the finalizer
once. The order by which finalizers are run is dictated by nesting:
innermost finalizers are run before outermost finalizers. For example,
in the following program, the finalizer
f1
is run before the finalizerf2
:{{{
F.onCancel(F.onCancel(F.canceled, f1), f2)
}}}
If a finalizer throws an error during evaluation, the error is suppressed,
and implementations may choose to report it via a side channel. Finalizers
are always uncancelable, so cannot otherwise be interrupted.
and implementations may choose to report it via a side channel. Finalizers
are always uncancelable, so cannot otherwise be interrupted.
- Value Params
- fa
-
The effect that is evaluated after
fin
is registered. - fin
-
The finalizer to register before evaluating
fa
.
- Inhertied from
- MonadCancel
def point[A](a: A): F[A]
point
lifts any value into a Monoidal Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> InvariantMonoidal[Option]
.point(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- InvariantMonoidal
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Similar to map2 but uses Eval to allow for laziness in the
argument. This can allow for "short-circuiting" of computations.
F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
map2Eval
does not short-circuitcomputations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example,
but
result of
that the result of
x.map2(bomb)(_ + _)
would result in an error,but
map2Eval
"short-circuits" the computation. x
is None
and thus theresult of
bomb
doesn't even need to be evaluated in order to determinethat the result of
map2Eval
should be None
.{{{
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
- Inhertied from
- Apply
def fromValidated[A](x: Validated[E, A]): F[A]
Convert from cats.data.Validated
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit]
.fromValidated(1.valid[Unit]
)
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromValidated(().invalid[Int]
)
res1: scala.Option[Int] = None
}}}
res1: scala.Option[Int] = None
}}}
- Inhertied from
- ApplicativeError
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Execute an action repeatedly until its result fails to satisfy the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
def raiseError[A](e: E): F[A]
Lift an error into the
F
context.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A]
= Either[String, A]
scala> divide[ErrorOr]
(6, 3)
res0: ErrorOr[Int] = Right(2)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr]
(6, 0)
res1: ErrorOr[Int] = Left(division by zero)
}}}
res1: ErrorOr[Int] = Left(division by zero)
}}}
- Inhertied from
- ApplicativeError
def fromTry[A](t: Try[A])(ev: Throwable <:< E): F[A]
If the error type is Throwable, we can convert from a scala.util.Try
- Inhertied from
- ApplicativeError
def composeFunctor[G <: ([_$3] =>> Any)](evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Compose Invariant
using F's
F[_]
and Functor G[_]
then produce Invariant[F[G[_]]]
using F's
imap
and G's map
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def composeApply[G <: ([_$2] =>> Any)](evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
- Inhertied from
- InvariantSemigroupal
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Recover from certain errors by mapping them to an
F[A]
value.- See also
- handleErrorWith to handle any/all errors.recover to recover from certain errors by mapping them to
A
values. - Inhertied from
- ApplicativeError
override def imap[A, B](fa: F[A])(f: A => B)(g: B => A): F[B]
- Definition Classes
- Functor -> Invariant
- Inhertied from
- Functor
override def map[A, B](fa: F[A])(f: A => B): F[B]
- Definition Classes
- Monad -> Applicative -> Functor
- Inhertied from
- Monad
def flatten[A](ffa: F[F[A]]): F[A]
"flatten" a nested
F
of F
structure into a single-layer F
structure.This is also commonly called
join
.Example:
{{{
scala> import cats.Eval
scala> import cats.implicits._
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]
] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
- Inhertied from
- FlatMap
def untilM[G <: ([_$4] =>> Any), A](f: F[A])(cond: => F[Boolean])(G: Alternative[G]): F[G[A]]
Execute an action repeatedly until the
The condition is evaluated after the loop body. Collects results into an
arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
condition returns true
.The condition is evaluated after the loop body. Collects results into an
arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
def unit: F[Unit]
Returns an
F[Unit]
value, equivalent with pure(())
.A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a
returned reference (e.g. it can be a
val
).Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.unit
res0: Option[Unit] = Some(())
}}}
res0: Option[Unit] = Some(())
}}}
- Inhertied from
- Applicative
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Execute an action repeatedly until the
The condition is evaluated after the loop body. Discards results.
Boolean
condition returns true
.The condition is evaluated after the loop body. Discards results.
- Inhertied from
- Monad
The child fiber is canceled in two cases: either the resource goes out
of scope or the parent fiber is cancelled. If the child fiber terminates
before one of these cases occurs, then cancellation is a no-op. This
avoids fiber leaks because the child fiber is always canceled before
the parent fiber drops the reference to it.
of scope or the parent fiber is cancelled. If the child fiber terminates
before one of these cases occurs, then cancellation is a no-op. This
avoids fiber leaks because the child fiber is always canceled before
the parent fiber drops the reference to it.
{{{
// Starts a fiber that continously prints "A".
// After 10 seconds, the resource scope exits so the fiber is canceled.
F.background(F.delay(println("A")).foreverM).use { _ =>
F.sleep(10.seconds)
}
// After 10 seconds, the resource scope exits so the fiber is canceled.
F.background(F.delay(println("A")).foreverM).use { _ =>
F.sleep(10.seconds)
}
}}}
- Value Params
- fa
-
the effect for the spawned fiber
- Inhertied from
- GenSpawn
override def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
- Definition Classes
- FlatMap -> Apply -> Semigroupal
- Inhertied from
- FlatMap
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the left.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
- Inhertied from
- Functor
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.- See also
- handleError to handle any error by simply mapping it to an
A
value instead of anF[A]
.recoverWith to recover from only certain errors. - Inhertied from
- ApplicativeError
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Apply a monadic function and discard the result while keeping the effect.
{{{
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
- Inhertied from
- FlatMap
Masks cancellation on the current fiber. The argument to
Polling causes a fiber to unmask within a masked region so that
cancellation can be observed again.
body
of typePoll[F]
is a natural transformation F ~> F
that enables polling.Polling causes a fiber to unmask within a masked region so that
cancellation can be observed again.
In the following example, cancellation can be observed only within
and nowhere else:
fb
and nowhere else:
{{{
F.uncancelable { poll =>
fa *> poll(fb) *> fc
}
fa *> poll(fb) *> fc
}
}}}
If a fiber is canceled while it is masked, the cancellation is suppressed
for as long as the fiber remains masked. Whenever the fiber is completely
unmasked again, the cancellation will be respected.
for as long as the fiber remains masked. Whenever the fiber is completely
unmasked again, the cancellation will be respected.
Masks can also be stacked or nested within each other. If multiple masks
are active, all masks must be undone so that cancellation can be observed.
In order to completely unmask within a multi-masked region, the poll
corresponding to each mask must be applied, innermost-first.
are active, all masks must be undone so that cancellation can be observed.
In order to completely unmask within a multi-masked region, the poll
corresponding to each mask must be applied, innermost-first.
{{{
F.uncancelable { p1 =>
F.uncancelable { p2 =>
fa *> p2(p1(fb)) *> fc
}
}
F.uncancelable { p2 =>
fa *> p2(p1(fb)) *> fc
}
}
}}}
The following operations are no-ops:
-
Polling in the wrong order
-
Applying the same poll more than once:
poll(poll(fa))
-
Applying a poll bound to one fiber within another fiber
- Inhertied from
- MonadCancel
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Turns a successful value into an error if it does not satisfy a given predicate.
- Inhertied from
- MonadError
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Sequentially compose two actions, discarding any value produced by the second. This variant of
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
- Inhertied from
- FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Sequentially compose two actions, discarding any value produced by the first. This variant of
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
- Inhertied from
- FlatMap
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Execute a callback on certain errors, then rethrow them.
Any non matching error is rethrown as well.
Any non matching error is rethrown as well.
In the following example, only one of the errors is logged,
but they are both rethrown, to be possibly handled by another
layer of the program:
but they are both rethrown, to be possibly handled by another
layer of the program:
{{{
scala> import cats., data., implicits._
scala> import cats., data., implicits._
scala> case class Err(msg: String)
scala> type F[A]
= EitherT[State[String, *]
, Err, A]
scala> val action: PartialFunction[Err, F[Unit]
] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int]
= (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]
) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
- Inhertied from
- ApplicativeError
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- Inhertied from
- ApplicativeError
override def adaptError[A](fa: F[A])(pf: PartialFunction[E, E]): F[A]
- Definition Classes
- MonadError -> ApplicativeError
- Inhertied from
- MonadError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or map
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
Usage of
redeem
subsumes handleError because:{{{
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- ApplicativeError
def lift[A, B](f: A => B): F[A] => F[B]
Lift a function f to operate on Functors
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
- Inhertied from
- Functor
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Turns a successful value into an error specified by the
error
function if it does not satisfy a given predicate.- Inhertied from
- MonadError
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Apply a monadic function iteratively until its result satisfies
the given predicate and return that result.
the given predicate and return that result.
- Inhertied from
- Monad
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or bind
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
Usage of
redeemWith
subsumes handleErrorWith because:{{{
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
Usage of
redeemWith
also subsumes flatMap because:{{{
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- bind
-
is the function that gets to transform the source
in case of success - fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- MonadError
override def productR[A, B](fa: F[A])(fb: F[B]): F[B]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
def parTraverseN[T <: ([_$3] =>> Any), A, B](n: Int)(ta: T[A])(f: A => F[B])(evidence$2: Traverse[T]): F[T[B]]
Like
Note that the semantics of this operation aim to maximise
fairness: when a spot to execute becomes available, every task
has a chance to claim it, and not only the next
Parallel.parTraverse
, but limits the degree of parallelism.Note that the semantics of this operation aim to maximise
fairness: when a spot to execute becomes available, every task
has a chance to claim it, and not only the next
n
tasks in ta
- Inhertied from
- GenConcurrent
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Given
fa
and n
, apply fa
n
times to construct an F[List[A]]
value.Example:
{{{
scala> import cats.data.State
{{{
scala> import cats.data.State
scala> type Counter[A]
= State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
- Inhertied from
- Applicative
A low-level primitive for starting the concurrent evaluation of a fiber.
Returns a Fiber that can be used to wait for a fiber or cancel it.
Returns a Fiber that can be used to wait for a fiber or cancel it.
start is a cancellation-unsafe function; it is recommended to
use the safer variant, background, to spawn fibers.
use the safer variant, background, to spawn fibers.
- Value Params
- fa
-
the effect for the fiber
- See also
- background for the safer, recommended variant
- Inhertied from
- GenSpawn
override def racePair[A, B](fa: F[A], fb: F[B]): F[Either[(Outcome[F, E, A], Fiber[F, E, B]), (Fiber[F, E, A], Outcome[F, E, B])]]
- Definition Classes
- Inhertied from
- GenConcurrent
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Apply a monadic function iteratively until its result fails
to satisfy the given predicate and return that result.
to satisfy the given predicate and return that result.
- Inhertied from
- Monad
def composeContravariantMonoidal[G <: ([_$3] =>> Any)](evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Compose an
Applicative[F]
and a ContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.byString, Int
scala> val strLength: Order[String] = Order.byString, Int
scala> val stringOrders: List[Order[String]
] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List]
.composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the
//
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
product
of the string order list and the int order list//
p
contains a list of the following orders:// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
- Inhertied from
- Applicative
def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.If
an exception, the exception is returned.
use
succeeds the returned value B
is returned. If use
returnsan exception, the exception is returned.
acquire
is uncancelable by default, but can be unmasked.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action which can be canceled
- release
-
the lifecycle release action which depends on the outcome of
use
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- Inhertied from
- MonadCancel
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
An
This function combines the effects of the
in the order in which they are given.
if-then-else
lifted into the F
context.This function combines the effects of the
fcond
condition and of the two branches,in the order in which they are given.
The value of the result is, depending on the value of the condition,
the value of the first argument, or the value of the second argument.
the value of the first argument, or the value of the second argument.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val b1: Option[Boolean]
= Some(true)
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val b2: Option[Boolean]
= Some(false)
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val b3: Option[Boolean]
= Some(true)
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
}}}
- Inhertied from
- Apply
def catchNonFatal[A](a: => A)(ev: Throwable <:< E): F[A]
Often E is Throwable. Here we try to call pure or catch
and raise.
and raise.
- Inhertied from
- ApplicativeError
override def map2[A, B, Z](fa: F[A], fb: F[B])(f: (A, B) => Z): F[Z]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Lifts
if
to FunctorExample:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
}}}
res0: List[Int] = List(1, 0, 0)
}}}
- Inhertied from
- Functor
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Similar to attempt, but wraps the result in a data.EitherT for
convenience.
convenience.
- Inhertied from
- ApplicativeError
An effect that requests self-cancellation on the current fiber.
In the following example, the fiber requests self-cancellation in a masked
region, so cancellation is suppressed until the fiber is completely
unmasked.
region, so cancellation is suppressed until the fiber is completely
unmasked.
fa
will run but fb
will not.{{{
F.uncancelable { _ =>
F.canceled *> fa
} *> fb
F.canceled *> fa
} *> fb
}}}
- Inhertied from
- MonadCancel
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Returns the given argument (mapped to Unit) if
unit lifted into F.
cond
is true
, otherwise,unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
res0: List[Unit] = List((), (), ())
scala> Applicative[List]
.whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
res1: List[Unit] = List(())
scala> Applicative[List]
.whenA(true)(List.empty[Int]
)
res2: List[Unit] = List()
res2: List[Unit] = List()
scala> Applicative[List]
.whenA(false)(List.empty[Int]
)
res3: List[Unit] = List(())
}}}
res3: List[Unit] = List(())
}}}
- Inhertied from
- Applicative
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
iterateForeverM is almost exclusively useful for effect types. For instance,
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
- Inhertied from
- FlatMap
@noop
def foreverM[A, B](fa: F[A]): F[B]
Like an infinite loop of >> calls. This is most useful effect loops
that you want to run forever in for instance a server.
that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing]
.
Be careful using this.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
- Inhertied from
- FlatMap
def widen[A, B >: A](fa: F[A]): F[B]
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a
implemented as a type cast. It could be implemented as
according to the functor laws, that should be equal to
cast is often much more performant.
See this example
of
equality this can result in a
ClassCastException
, because it isimplemented as a type cast. It could be implemented as
map(identity)
, butaccording to the functor laws, that should be equal to
fa
, and a typecast is often much more performant.
See this example
of
widen
creating a ClassCastException
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
- Inhertied from
- Functor
def catchNonFatalEval[A](a: Eval[A])(ev: Throwable <:< E): F[A]
Often E is Throwable. Here we try to call pure or catch
and raise
and raise
- Inhertied from
- ApplicativeError
def attempt[A](fa: F[A]): F[Either[E, A]]
Handle errors by turning them into scala.util.Either values.
If there is no error, then an
scala.util.Right
value will be returned instead.All non-fatal errors should be handled by this method.
- Inhertied from
- ApplicativeError
Introduces a fairness boundary that yields control back to the scheduler
of the runtime system. This allows the carrier thread to resume execution
of another waiting fiber.
of the runtime system. This allows the carrier thread to resume execution
of another waiting fiber.
Note that
have the liberty to interpret this method to their liking as long as it
obeys the respective laws. For example, a lawful, but atypical,
implementation of this function is
boundary is a no-op.
cede
is merely a hint to the runtime system; implementationshave the liberty to interpret this method to their liking as long as it
obeys the respective laws. For example, a lawful, but atypical,
implementation of this function is
F.unit
, in which case the fairnessboundary is a no-op.
- Inhertied from
- GenSpawn
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in
the implementing type already had a built-in
.map
method.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val m: Map[Int, String]
= Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
- Inhertied from
- Functor
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the right.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
- Inhertied from
- Functor
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Keeps calling
f
until a scala.util.Right[B]
is returned.Based on Phil Freeman's
Stack Safety for Free.
Stack Safety for Free.
Implementations of this method should use constant stack space relative to
f
.- Inhertied from
- FlatMap
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Inverse of
attempt
Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]
] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]
] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Returns the given argument (mapped to Unit) if
otherwise, unit lifted into F.
cond
is false
,otherwise, unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
res0: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
res1: List[Unit] = List((), (), ())
scala> Applicative[List]
.unlessA(true)(List.empty[Int]
)
res2: List[Unit] = List(())
res2: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List.empty[Int]
)
res3: List[Unit] = List()
}}}
res3: List[Unit] = List()
}}}
- Inhertied from
- Applicative
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into
then recovers the original value or error back into
F
.Note that if the effect returned by
f
fails, the resulting effect will fail too.Alias for
fa.attempt.flatTap(f).rethrow
for convenience.Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]
): Try[String]
= result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int]
= Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int]
= Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def void[A](fa: F[A]): F[Unit]
Empty the fa of the values, preserving the structure
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.void(List(1,2,3))
res0: List[Unit] = List((), (), ())
}}}
res0: List[Unit] = List((), (), ())
}}}
- Inhertied from
- Functor
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
if
lifted into monad.- Inhertied from
- FlatMap
override def productL[A, B](fa: F[A])(fb: F[B]): F[A]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
Specifies an effect that is always invoked after evaluation of
completes, but depends on the outcome.
fa
completes, but depends on the outcome.
- Value Params
- fa
-
The effect that is run after
fin
is registered. - fin
-
A function that returns the effect to run based on the
outcome.
- See also
- bracketCase for a more powerful variantOutcome for the various outcomes of evaluation
- Inhertied from
- MonadCancel
def compose[G <: ([_$2] =>> Any)](evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Compose an
Applicative[F]
and an Applicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Applicative[List]
.compose[Option]
scala> alo.pure(3)
res0: List[Option[Int] ] = List(Some(3))
res0: List[Option[Int] ] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Applicative
def compose[G <: ([_$2] =>> Any)](evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Compose Invariant
F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def compose[G <: ([_$3] =>> Any)](evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Compose an
Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Apply[List]
.compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Apply
def compose[G <: ([_$6] =>> Any)](evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
- Inhertied from
- Functor
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Execute an action repeatedly until its result satisfies the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
Races the evaluation of two fibers and returns the Outcome of both. If
the race is canceled before one or both participants complete, then
then whichever ones are incomplete are canceled.
the race is canceled before one or both participants complete, then
then whichever ones are incomplete are canceled.
Races the evaluation of two fibers that returns the result of the winner,
except in the case of cancellation.
except in the case of cancellation.
The semantics of race are described by the following rules:
-
If the winner completes with Succeeded, the race returns the
successful value. The loser is canceled before returning. -
If the winner completes with Errored, the race raises the error.
The loser is canceled before returning. -
If the winner completes with Canceled, the race returns the
result of the loser, consistent with the first two rules. -
If both the winner and loser complete with Canceled, the race
is canceled. -
If the race is masked and is canceled because both participants
canceled, the fiber will block indefinitely.
- Value Params
- fa
-
the effect for the first racing fiber
- fb
-
the effect for the second racing fiber
- See also
- raceOutcome for a variant that returns the outcome of the winner.
- Inhertied from
- GenSpawn
A non-terminating effect that never completes, which causes a fiber to
semantically block indefinitely. This is the purely functional,
asynchronous equivalent of an infinite while loop in Java, but no
native threads are blocked.
semantically block indefinitely. This is the purely functional,
asynchronous equivalent of an infinite while loop in Java, but no
native threads are blocked.
A fiber that is suspended in never can be canceled if it is
completely unmasked before it suspends:
completely unmasked before it suspends:
{{{
// ignoring race conditions between
F.never.start.flatMap(_.cancel) <-> F.unit
start
and cancel
F.never.start.flatMap(_.cancel) <-> F.unit
}}}
However, if the fiber is masked, cancellers will be semantically blocked
forever:
forever:
{{{
// ignoring race conditions between
F.uncancelable(_ => F.never).start.flatMap(_.cancel) <-> F.never
start
and cancel
F.uncancelable(_ => F.never).start.flatMap(_.cancel) <-> F.never
}}}
- Inhertied from
- GenSpawn
override def ap[A, B](ff: F[A => B])(fa: F[A]): F[B]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
Races the evaluation of two fibers and returns the result of both.
The following rules describe the semantics of both:
-
If the winner completes with Succeeded, the race waits for the
loser to complete. -
If the winner completes with Errored, the race raises the error.
The loser is canceled. -
If the winner completes with Canceled, the loser and the race
are canceled as well. -
If the loser completes with Succeeded, the race returns the
successful value of both fibers. -
If the loser completes with Errored, the race returns the error.
-
If the loser completes with Canceled, the race is canceled.
-
If the race is canceled before one or both participants complete,
then whichever ones are incomplete are canceled. -
If the race is masked and is canceled because one or both
participants canceled, the fiber will block indefinitely.
- Value Params
- fa
-
the effect for the first racing fiber
- fb
-
the effect for the second racing fiber
- See also
- Inhertied from
- GenSpawn
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Recover from certain errors by mapping them to an
A
value.- See also
- handleError to handle any/all errors.recoverWith to recover from certain errors by mapping them to
F[A]
values. - Inhertied from
- ApplicativeError
Analogous to productR, but suppresses short-circuiting behavior
except for cancellation.
except for cancellation.
- Inhertied from
- MonadCancel
override def ap2[A, B, Z](ff: F[(A, B) => Z])(fa: F[A], fb: F[B]): F[Z]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
A pattern for safely interacting with effectful lifecycles.
If
fails, or is canceled,
acquire
completes successfully, use
is called. If use
succeeds,fails, or is canceled,
release
is guaranteed to be called exactly once.acquire
is uncancelable.release
is uncancelable.use
is cancelable by default, but can be masked.- Value Params
- acquire
-
the lifecycle acquisition action
- release
-
the lifecycle release action
- use
-
the effect to which the lifecycle is scoped, whose result
is the return value of this function
- See also
- bracketCase for a more powerful variantResource for a composable datatype encoding of effectful lifecycles
- Inhertied from
- MonadCancel