core for pipes splitAt defined with and without next

chunkX.hs core

chunkX.hs
==================== CorePrep ====================
Result size of CorePrep
  = {terms: 634, types: 1,774, coercions: 269}


Rec {
$snext2
$snext2 =
  \ @ a_XcUd @ r_XcUg p_sg9n eta_sg9o ->
    case p_sg9n of _ {
      Request _ _ -> case lvl2_rg89 of _ { };
      Respond a1_sg9t fu_sg9u ->
        let {
          sat_sg9v
          sat_sg9v = fu_sg9u () } in
        let {
          sat_sg9w
          sat_sg9w = (a1_sg9t, sat_sg9v) } in
        let {
          sat_sg9x
          sat_sg9x = Right sat_sg9w } in
        (# eta_sg9o, sat_sg9x #);
      M m1_sg9y ->
        let! { (# ipv_sg9A, ipv1_sg9B #) ~ _
        <- (m1_sg9y `cast` ...) eta_sg9o } in
        $snext2 ipv1_sg9B ipv_sg9A;
      Pure r1_sg9C ->
        let {
          sat_sg9D
          sat_sg9D = Left r1_sg9C } in
        (# eta_sg9o, sat_sg9D #)
    }
end Rec }

Rec {
$w$ssplit_rg8g
$w$ssplit_rg8g =
  \ @ a_aaal @ r_aaan ww_sgag w_sgah ->
    case ww_sgag of ds_sgai {
      __DEFAULT ->
        let {
          sat_sgaz
          sat_sgaz =
            (\ s_sgaj ->
               let! { (# ipv_sgal, ipv1_sgam #) ~ _ <- $snext2 w_sgah s_sgaj } in
               let {
                 sat_sgay
                 sat_sgay =
                   case ipv1_sgam of _ {
                     Left r1_sgao ->
                       let {
                         sat_sgap
                         sat_sgap = Pure r1_sgao } in
                       Pure sat_sgap;
                     Right ds2_sgaq ->
                       let! { (a1_sgas, p'_sgat) ~ _ <- ds2_sgaq } in
                       let {
                         k_sgau
                         k_sgau =
                           let! { __DEFAULT ~ sat_sgav <- -# ds_sgai 1 } in
                           $w$ssplit_rg8g sat_sgav p'_sgat } in
                       let {
                         sat_sgax
                         sat_sgax = \ _ -> k_sgau } in
                       Respond a1_sgas sat_sgax
                   } } in
               (# ipv_sgal, sat_sgay #))
            `cast` ... } in
        M sat_sgaz;
      0 -> Pure w_sgah
    }
end Rec }

Rec {
main8
main8 =
  \ p_sgaQ s_sgaR ->
    let! { (# ipv_sgaT, ipv1_sgaU #) ~ _ <- $snext2 p_sgaQ s_sgaR } in
    let {
      sat_sgb6
      sat_sgb6 =
        case ipv1_sgaU of _ {
          Left r_sgaW -> Pure r_sgaW;
          Right ds_sgaX ->
            let! { (a_sgaZ, p'_sgb0) ~ _ <- ds_sgaX } in
            let {
              sat_sgb5
              sat_sgb5 =
                let {
                  sat_sgb2
                  sat_sgb2 = \ _ -> p'_sgb0 } in
                let {
                  sat_sgb3
                  sat_sgb3 = Respond a_sgaZ sat_sgb2 } in
                let! { __DEFAULT ~ sat_sgb4 <- $w$ssplit_rg8g 10 sat_sgb3 } in
                $fApplicativeProxy_$cfmap
                  $fMonadIO (main8 `cast` ...) sat_sgb4 } in
            Free sat_sgb5
        } } in
    (# ipv_sgaT, sat_sgb6 #)
end Rec }

chunkZ.hs core

chunkZ.hs
==================== CorePrep ====================
Result size of CorePrep
  = {terms: 629, types: 1,668, coercions: 274}


Rec {
$s$w$ssplit_rg6I
$s$w$ssplit_rg6I =
  \ sc_sg8t sc1_sg8u sc2_sg8v ->
    case sc_sg8t of ds_sg8w {
      __DEFAULT ->
        let! { __DEFAULT ~ a_sg8x <- -# ds_sg8w 1 } in
        let {
          sat_sg8A
          sat_sg8A =
            \ x1_sg8y ->
              let {
                sat_sg8z
                sat_sg8z = sc2_sg8v x1_sg8y } in
              $w$ssplit_rg6J a_sg8x sat_sg8z } in
        Respond sc1_sg8u sat_sg8A;
      0 ->
        let {
          sat_sg8B
          sat_sg8B = Respond sc1_sg8u sc2_sg8v } in
        Pure sat_sg8B
    }

$w$ssplit_rg6J
$w$ssplit_rg6J =
  \ @ a_aaaj @ r_aaal ww_sg8C w_sg8D ->
    case ww_sg8C of ds_sg8E {
      __DEFAULT ->
        case w_sg8D of wild_sg8F {
          Request _ _ -> lvl6_rg6H;
          Respond a1_sg8I f1_sg8J ->
            let! { __DEFAULT ~ a2_sg8K <- -# ds_sg8E 1 } in
            let {
              sat_sg8N
              sat_sg8N =
                \ x1_sg8L ->
                  let {
                    sat_sg8M
                    sat_sg8M = f1_sg8J x1_sg8L } in
                  $w$ssplit_rg6J a2_sg8K sat_sg8M } in
            Respond a1_sg8I sat_sg8N;
          M m_sg8O ->
            let {
              sat_sg8U
              sat_sg8U =
                (\ s_sg8P ->
                   let! { (# ipv_sg8R, ipv1_sg8S #) ~ _
                   <- (m_sg8O `cast` ...) s_sg8P } in
                   let {
                     sat_sg8T
                     sat_sg8T = $w$ssplit_rg6J ds_sg8E ipv1_sg8S } in
                   (# ipv_sg8R, sat_sg8T #))
                `cast` ... } in
            M sat_sg8U;
          Pure _ -> Pure wild_sg8F
        };
      0 -> Pure w_sg8D
    }
end Rec }


Rec {
main8
main8 =
  \ p_sg9c eta_sg9d ->
    case p_sg9c of _ {
      Request _ _ -> case lvl8_rg6L of _ { };
      Respond ipv_sg9i ipv1_sg9j ->
        let {
          sat_sg9l
          sat_sg9l =
            let! { __DEFAULT ~ sat_sg9k
            <- $s$w$ssplit_rg6I 10 ipv_sg9i ipv1_sg9j } in
            $fApplicativeProxy_$cfmap
              $fMonadIO (main8 `cast` ...) sat_sg9k } in
        let {
          sat_sg9m
          sat_sg9m = Free sat_sg9l } in
        (# eta_sg9d, sat_sg9m #);
      M m_sg9n ->
        let! { (# ipv_sg9p, ipv1_sg9q #) ~ _
        <- (m_sg9n `cast` ...) eta_sg9d } in
        main8 ipv1_sg9q ipv_sg9p;
      Pure r_sg9r ->
        let {
          sat_sg9s
          sat_sg9s = Pure r_sg9r } in
        (# eta_sg9d, sat_sg9s #)
    }
end Rec }