object
      
      
        MonadLaws
      
      
      
          
        
      
      
        
        
        
        
        
              Value Members
              - 
      
      
      
      
        final 
        def
      
      
        !=(arg0: Any): Boolean
      
        
- 
      
      
      
      
        final 
        def
      
      
        ##(): Int
      
        
- 
      
      
      
      
        final 
        def
      
      
        ==(arg0: Any): Boolean
      
        
- 
      
      
      
      
        final 
        def
      
      
        asInstanceOf[T0]: T0
      
        
- 
      
      
      
      
        
        def
      
      
        associative[M[_], T, U, V](eq: (M[V], M[V]) ⇒ Boolean)(implicit monad: Monad[M], arb: Arbitrary[M[T]], fn1: Arbitrary[(T) ⇒ M[U]], fn2: Arbitrary[(U) ⇒ M[V]]): Prop
      
        
- 
      
      
      
      
        
        def
      
      
        associativeEquiv[M[_], T, U, V](implicit monad: Monad[M], arb: Arbitrary[M[T]], fn1: Arbitrary[(T) ⇒ M[U]], fn2: Arbitrary[(U) ⇒ M[V]], equiv: Equiv[M[V]]): Prop
      
        
- 
      
      
      
      
        
        def
      
      
        clone(): AnyRef
      
        
- 
      
      
      
      
        
        def
      
      
        defaultEq[T]: (T, T) ⇒ Boolean
      
        
- 
      
      
      
      
        final 
        def
      
      
        eq(arg0: AnyRef): Boolean
      
        
- 
      
      
      
      
        
        def
      
      
        equals(arg0: Any): Boolean
      
        
- 
      
      
      
      
        
        def
      
      
        finalize(): Unit
      
        
- 
      
      
      
      
        implicit 
        def
      
      
        fnArb[M[_], T, U](implicit map: Arbitrary[Map[T, M[U]]], arbu: Arbitrary[M[U]]): Arbitrary[(T) ⇒ M[U]]
      
        
- 
      
      
      
      
        final 
        def
      
      
        getClass(): Class[_]
      
        
- 
      
      
      
      
        
        def
      
      
        hashCode(): Int
      
        
- 
      
      
      
      
        implicit 
        def
      
      
        identityA[T](implicit arbl: Arbitrary[T]): Arbitrary[Identity[T]]
      
        
- 
      
      
      
      
        implicit 
        def
      
      
        indexedSeqA[T](implicit arbl: Arbitrary[List[T]]): Arbitrary[IndexedSeq[T]]
      
        
- 
      
      
      
      
        final 
        def
      
      
        isInstanceOf[T0]: Boolean
      
        
- 
      
      
      
      
        
        def
      
      
        leftIdentity[M[_], T, U](eq: (M[U], M[U]) ⇒ Boolean = defaultEq[M[U]])(implicit monad: Monad[M], arb: Arbitrary[T], arbfn: Arbitrary[(T) ⇒ M[U]]): Prop
      
        
- 
      
      
      
      
        
        def
      
      
        leftIdentityEquiv[M[_], T, U](implicit monad: Monad[M], arb: Arbitrary[T], arbfn: Arbitrary[(T) ⇒ M[U]], equiv: Equiv[M[U]]): Prop
      
        
- 
      
      
      
      
        
        def
      
      
        monadLaws[M[_], T, U, R](eq: (M[R], M[R]) ⇒ Boolean = defaultEq[M[R]])(implicit monad: Monad[M], arb: Arbitrary[M[T]], fn1: Arbitrary[(T) ⇒ M[U]], arbr: Arbitrary[M[R]], fn2: Arbitrary[(U) ⇒ M[R]], arbu: Arbitrary[U]): Prop
      
        
- 
      
      
      
      
        
        def
      
      
        monadLawsEquiv[M[_], T, U, R](implicit monad: Monad[M], arb: Arbitrary[M[T]], equivT: Equiv[M[T]], equivU: Equiv[M[U]], equivR: Equiv[M[R]], fn1: Arbitrary[(T) ⇒ M[U]], arbr: Arbitrary[M[R]], fn2: Arbitrary[(U) ⇒ M[R]], arbu: Arbitrary[U]): Prop
      
        
- 
      
      
      
      
        final 
        def
      
      
        ne(arg0: AnyRef): Boolean
      
        
- 
      
      
      
      
        final 
        def
      
      
        notify(): Unit
      
        
- 
      
      
      
      
        final 
        def
      
      
        notifyAll(): Unit
      
        
- 
      
      
      
      
        
        def
      
      
        rightIdentity[M[_], T](eq: (M[T], M[T]) ⇒ Boolean = defaultEq[M[T]])(implicit monad: Monad[M], arb: Arbitrary[M[T]]): Prop
      
        
- 
      
      
      
      
        
        def
      
      
        rightIdentityEquiv[M[_], T](implicit monad: Monad[M], arb: Arbitrary[M[T]], equiv: Equiv[M[T]]): Prop
      
        
- 
      
      
      
      
        implicit 
        def
      
      
        seqA[T](implicit arbl: Arbitrary[List[T]]): Arbitrary[Seq[T]]
      
        
- 
      
      
      
      
        implicit 
        def
      
      
        someA[T](implicit arbl: Arbitrary[T]): Arbitrary[Some[T]]
      
        
- 
      
      
      
      
        final 
        def
      
      
        synchronized[T0](arg0: ⇒ T0): T0
      
        
- 
      
      
      
      
        
        def
      
      
        toString(): String
      
        
- 
      
      
      
      
        implicit 
        def
      
      
        vectorA[T](implicit arbl: Arbitrary[List[T]]): Arbitrary[Vector[T]]
      
        
- 
      
      
      
      
        final 
        def
      
      
        wait(): Unit
      
        
- 
      
      
      
      
        final 
        def
      
      
        wait(arg0: Long, arg1: Int): Unit
      
        
- 
      
      
      
      
        final 
        def
      
      
        wait(arg0: Long): Unit
      
        
 
        
        
         
        
        
              
Inherited from AnyRef
            
              
Inherited from Any
            
        
         
        
       
      
      
     
      
Basic Monad laws, useful for testing any monad.