scala.io
object BytePickle

[source: `scala/io/BytePickle.scala`]

`` `object` BytePickle
  `extends` AnyRef

  Pickler combinators. Based on a Haskell library by Andrew Kennedy, see http://research.microsoft.com/~akenn/fun/.

Author
  Philipp Haller
Version
  1.1

Value Summary
`val` | DEF : Int
`val` | REF : Int

Method Summary
`def` | appendByte (a : Array[Byte], b : Int) : Array[Byte]
`def` | bool : SPU[Boolean]
`def` | byte : SPU[Byte]
`def` | bytearray : SPU[Array[Byte]]
`def` | data [a](tag : (a) => Int, ps : List[() => SPU[a]]) : SPU[a]
`def` | fixedList [a](pa : SPU[a])(n : Int) : SPU[List[a]]
`def` | lift [t](x : t) : SPU[t]
`def` | list [a](pa : SPU[a]) : SPU[List[a]]
`def` | nat : SPU[Int]
`def` | nat2Bytes (x : Int) : Array[Byte]
`def` | pair [a, b](pa : SPU[a], pb : SPU[b]) : SPU[(a, b)]
`def` | pickle [t](p : SPU[t], a : t) : Array[Byte]
`def` | refDef : PU[RefDef]
`def` | sequ [t, u](f : (u) => t, pa : SPU[t], k : (t) => SPU[u]) : SPU[u]
`def` | share [a](pa : SPU[a]) : SPU[a]
`def` | string : SPU[String]
`def` | triple [a, b, c](pa : SPU[a], pb : SPU[b], pc : SPU[c]) : SPU[(a, b, c)]
`def` | ufixedList [a](pa : PU[a])(n : Int) : PU[List[a]]
`def` | ulift [t](x : t) : PU[t]
`def` | ulist [a](pa : PU[a]) : PU[List[a]]
`def` | unat : PU[Int]
`def` | unpickle [t](p : SPU[t], stream : Array[Byte]) : t
`def` | upair [a, b](pa : PU[a], pb : PU[b]) : PU[(a, b)]
`def` | upickle [t](p : PU[t], a : t) : Array[Byte]
`def` | usequ [t, u](f : (u) => t, pa : PU[t], k : (t) => PU[u]) : PU[u]
`def` | uunpickle [t](p : PU[t], stream : Array[Byte]) : t
`def` | uwrap [a, b](i : (a) => b, j : (b) => a, pa : PU[a]) : PU[b]
`def` | wrap [a, b](i : (a) => b, j : (b) => a, pa : SPU[a]) : SPU[b]

Methods inherited from AnyRef
getClass, hashCode, equals, clone, toString, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized

Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf

Class Summary
`case class` | Def `extends` RefDef `with` Product
`abstract class` | PU [t]`extends` AnyRef
`class` | PicklerEnv `extends` HashMap[Any, Int]
`class` | PicklerState (`val` stream : Array[Byte], `val` dict : PicklerEnv)`extends` AnyRef
`case class` | Ref `extends` RefDef `with` Product
`abstract class` | RefDef `extends` AnyRef
`abstract class` | SPU [t]`extends` AnyRef
`class` | UnPicklerEnv `extends` HashMap[Int, Any]
`class` | UnPicklerState (`val` stream : Array[Byte], `val` dict : UnPicklerEnv)`extends` AnyRef

Value Details

`` `val` REF : Int

`` `val` DEF : Int

Method Details

`` `def` pickle[t](p : SPU[t], a : t) : Array[Byte]

`` `def` unpickle[t](p : SPU[t], stream : Array[Byte]) : t

`` `def` upickle[t](p : PU[t], a : t) : Array[Byte]

`` `def` uunpickle[t](p : PU[t], stream : Array[Byte]) : t

`` `def` refDef : PU[RefDef]

`` `def` unat : PU[Int]

`` `def` share[a](pa : SPU[a]) : SPU[a]

`` `def` ulift[t](x : t) : PU[t]

`` `def` lift[t](x : t) : SPU[t]

`` `def` usequ[t, u](f : (u) => t, pa : PU[t], k : (t) => PU[u]) : PU[u]

`` `def` sequ[t, u](f : (u) => t, pa : SPU[t], k : (t) => SPU[u]) : SPU[u]

`` `def` upair[a, b](pa : PU[a], pb : PU[b]) : PU[(a, b)]

`` `def` pair[a, b](pa : SPU[a], pb : SPU[b]) : SPU[(a, b)]

`` `def` triple[a, b, c](pa : SPU[a], pb : SPU[b], pc : SPU[c]) : SPU[(a, b, c)]

`` `def` uwrap[a, b](i : (a) => b, j : (b) => a, pa : PU[a]) : PU[b]

`` `def` wrap[a, b](i : (a) => b, j : (b) => a, pa : SPU[a]) : SPU[b]

`` `def` appendByte(a : Array[Byte], b : Int) : Array[Byte]

`` `def` nat2Bytes(x : Int) : Array[Byte]

`` `def` nat : SPU[Int]

`` `def` byte : SPU[Byte]

`` `def` string : SPU[String]

`` `def` bytearray : SPU[Array[Byte]]

`` `def` bool : SPU[Boolean]

`` `def` ufixedList[a](pa : PU[a])(n : Int) : PU[List[a]]

`` `def` fixedList[a](pa : SPU[a])(n : Int) : SPU[List[a]]

`` `def` list[a](pa : SPU[a]) : SPU[List[a]]

`` `def` ulist[a](pa : PU[a]) : PU[List[a]]

`` `def` data[a](tag : (a) => Int, ps : List[() => SPU[a]]) : SPU[a]