Add support for some list functions (finos#49)

sfc-gh-lfallasavendano · sfc-gh-lfallasavendano · commit 9d1bed323429 · 2023-12-13T16:11:40.000-06:00
* Add support for some list functions

Adds basic support for:
- `List.map` with lambda returning record
- `List.map` with lambda returning a single value
- `List.filter` with lambda predicate
- `List.sum` with `List.map` as its collection

* Fixes for Code review comments
diff --git a/src/Morphir/Snowpark/AccessElementMapping.elm b/src/Morphir/Snowpark/AccessElementMapping.elm
@@ -43,8 +43,6 @@ mapVariableAccess : (IrType.Type a) -> Name.Name -> ValueMappingContext -> Scala
 mapVariableAccess _ name _ =
    Scala.Variable (name |> Name.toCamelCase)   
 
-
-
 mapConstructorAccess : (IrType.Type a) -> FQName.FQName -> ValueMappingContext -> Scala.Value
 mapConstructorAccess tpe name ctx =
     case tpe of
diff --git a/src/Morphir/Snowpark/MapFunctionsMapping.elm b/src/Morphir/Snowpark/MapFunctionsMapping.elm
@@ -1,11 +1,20 @@
-module Morphir.Snowpark.MapFunctionsMapping exposing (..)
+module Morphir.Snowpark.MapFunctionsMapping exposing (mapFunctionsMapping)
+
+import Dict as Dict
 import Morphir.Scala.AST as Scala
 import Morphir.IR.Value as Value exposing (Pattern(..), Value(..))
 import Morphir.IR.Type exposing (Type)
-import Morphir.Snowpark.MappingContext exposing (ValueMappingContext)
+import Morphir.Snowpark.MappingContext exposing (ValueMappingContext, isCandidateForDataFrame)
+import Morphir.IR.Value exposing (valueAttribute)
+import Morphir.IR.Type as Type
+import Morphir.Snowpark.MappingContext exposing (isAnonymousRecordWithSimpleTypes)
+import Morphir.IR.Name as Name
+import Morphir.Snowpark.Constants exposing (applySnowparkFunc)
+import Morphir.Snowpark.MappingContext exposing (isBasicType)
 
+type alias MapValueType ta = Value ta (Type ()) -> ValueMappingContext -> Scala.Value
 
-mapFunctionsMapping : Value ta (Type ()) -> (Value ta (Type ()) -> ValueMappingContext -> Scala.Value) -> ValueMappingContext -> Scala.Value
+mapFunctionsMapping : Value ta (Type ()) -> MapValueType ta -> ValueMappingContext -> Scala.Value
 mapFunctionsMapping value mapValue ctx =
     case value of
         Value.Apply _ (Value.Apply _ (Value.Reference _ ( [ [ "morphir" ], [ "s", "d", "k" ] ], [ [ "list" ] ], [ "member" ] )) predicate) sourceRelation ->
@@ -14,5 +23,95 @@ mapFunctionsMapping value mapValue ctx =
                 applySequence = mapValue sourceRelation ctx
             in
             Scala.Apply (Scala.Select variable "in") [ Scala.ArgValue Nothing applySequence ]
+        Value.Apply _ (Value.Apply _ (Value.Reference _ ( [ [ "morphir" ], [ "s", "d", "k" ] ], [ [ "list" ] ], [ "map" ] )) projection) sourceRelation ->
+            generateForListMap projection sourceRelation ctx mapValue
+        Value.Apply _ (Value.Apply _ (Value.Reference _ ( [ [ "morphir" ], [ "s", "d", "k" ] ], [ [ "list" ] ], [ "filter" ] )) predicate) sourceRelation ->
+            generateForListFilter predicate sourceRelation ctx mapValue
+        Value.Apply _ (Value.Apply _ (Value.Reference _ ( [ [ "morphir" ], [ "s", "d", "k" ] ], [ [ "list" ] ], [ "filter", "map" ] )) predicateAction) sourceRelation ->
+            generateForListFilterMap predicateAction sourceRelation ctx mapValue
+        Value.Apply _ (Value.Reference _ ( [ [ "morphir" ], [ "s", "d", "k" ] ], [ [ "list" ] ], [ "sum" ] )) collection ->
+            generateForListSum collection ctx mapValue
+        _ ->
+            Scala.Literal (Scala.StringLit "To Do")
+
+
+generateForListSum : Value ta (Type ()) -> ValueMappingContext -> MapValueType ta -> Scala.Value
+generateForListSum collection ctx mapValue =
+    case collection of
+        Value.Apply _ (Value.Apply _ (Value.Reference _ ( [ [ "morphir" ], [ "s", "d", "k" ] ], [ [ "list" ] ], [ "map" ] )) _) sourceRelation ->
+            if isCandidateForDataFrame (valueAttribute sourceRelation) ctx.typesContextInfo then
+                case mapValue collection ctx of
+                    Scala.Apply col [Scala.ArgValue argName projectedExpr] ->
+                        let
+                            resultName = Scala.Literal (Scala.StringLit "result")
+                            asCall =  Scala.Apply (Scala.Select projectedExpr "as") [Scala.ArgValue Nothing resultName]
+                            newSelect = Scala.Apply col [Scala.ArgValue argName asCall]
+                            sumCall = applySnowparkFunc "sum" [applySnowparkFunc "col" [resultName]]
+                        in
+                            Scala.Apply (Scala.Select newSelect "select") [Scala.ArgValue Nothing sumCall]
+                    _ ->
+                        Scala.Literal (Scala.StringLit "Unsupported sum scenario")
+            else 
+                Scala.Literal (Scala.StringLit "Unsupported sum scenario")
+        _ -> 
+            Scala.Literal (Scala.StringLit "Unsupported sum scenario")
+
+generateForListFilter : Value ta (Type ()) -> (Value ta (Type ())) -> ValueMappingContext -> MapValueType ta -> Scala.Value
+generateForListFilter predicate sourceRelation ctx mapValue =
+    if isCandidateForDataFrame (valueAttribute sourceRelation) ctx.typesContextInfo then
+        case predicate of
+           Value.Lambda _ _ binExpr ->
+              Scala.Apply (Scala.Select (mapValue sourceRelation ctx) "filter") [Scala.ArgValue Nothing <| mapValue binExpr ctx]
+           _ ->
+              Scala.Literal (Scala.StringLit "To Do")
+     else 
+        Scala.Literal (Scala.StringLit "Unsupported filter scenario")
+
+
+generateForListFilterMap : Value ta (Type ()) -> (Value ta (Type ())) -> ValueMappingContext -> MapValueType ta -> Scala.Value
+generateForListFilterMap predicate sourceRelation ctx mapValue =
+    if isCandidateForDataFrame (valueAttribute sourceRelation) ctx.typesContextInfo then
+        case predicate of
+           Value.Lambda _ _ binExpr ->
+              let 
+                  selectCall = Scala.Apply (Scala.Select (mapValue sourceRelation ctx) "select") [Scala.ArgValue Nothing <| mapValue binExpr ctx]
+                  resultId = Scala.Literal <| Scala.StringLit "result"
+                  selectColumnAlias = Scala.Apply (Scala.Select selectCall "as ") [ Scala.ArgValue Nothing resultId ]
+                  isNotNullCall = Scala.Select (applySnowparkFunc "col" [ resultId ]) "is_not_null"
+              in
+              Scala.Apply (Scala.Select selectColumnAlias "filter") [Scala.ArgValue Nothing isNotNullCall]
+           _ ->
+              Scala.Literal (Scala.StringLit "Unsupported filterMap scenario")
+     else 
+        Scala.Literal (Scala.StringLit "Unsupported filterMap scenario")
+
+generateForListMap : Value ta (Type ()) -> (Value ta (Type ())) -> ValueMappingContext -> MapValueType ta -> Scala.Value
+generateForListMap projection sourceRelation ctx mapValue =
+    if isCandidateForDataFrame (valueAttribute sourceRelation) ctx.typesContextInfo then
+        case processLambdaWithRecordBody projection ctx mapValue of
+           Just arguments -> 
+              Scala.Apply (Scala.Select (mapValue sourceRelation ctx) "select") arguments
+           Nothing ->
+              Scala.Literal (Scala.StringLit "Unsupported map scenario")
+     else 
+        Scala.Literal (Scala.StringLit "Unsupported map scenario")
+
+processLambdaWithRecordBody : Value ta (Type ()) -> ValueMappingContext -> MapValueType ta -> Maybe (List Scala.ArgValue)
+processLambdaWithRecordBody functionExpr ctx mapValue =
+    case functionExpr of
+        Value.Lambda (Type.Function _ _  returnType) (Value.AsPattern _ _ _) (Value.Record _ fields) ->
+             if isAnonymousRecordWithSimpleTypes returnType ctx.typesContextInfo then
+               Just (fields  
+                        |> Dict.toList
+                        |> List.map (\(fieldName, value) -> (Name.toCamelCase fieldName, (mapValue value ctx)))
+                        |> List.map (\(fieldName, value) ->  Scala.Apply (Scala.Select value  "as") [Scala.ArgValue Nothing (Scala.Literal (Scala.StringLit fieldName))])
+                        |> List.map (Scala.ArgValue Nothing))
+             else  
+                Nothing
+        Value.Lambda (Type.Function _ _  returnType) (Value.AsPattern _ _ _) expr ->
+             if isBasicType returnType then
+               Just [ Scala.ArgValue Nothing <| mapValue expr ctx ]
+             else  
+                Nothing
         _ ->
-            Scala.Literal (Scala.StringLit "To Do")
+            Nothing
diff --git a/src/Morphir/Snowpark/MappingContext.elm b/src/Morphir/Snowpark/MappingContext.elm
@@ -11,7 +11,8 @@ module Morphir.Snowpark.MappingContext exposing
       , emptyContext
       , isCandidateForDataFrame
       , ValueMappingContext
-      , emptyValueMappingContext )
+      , emptyValueMappingContext
+      , isAnonymousRecordWithSimpleTypes )
 
 {-| This module contains functions to collect information about type definitions in a distribution.
 It classifies type definitions in the following kinds:
@@ -79,7 +80,6 @@ isUnionTypeRefWithoutParams tpe ctx =
        Type.Reference _ name _ -> isUnionTypeWithoutParams name ctx
        _ -> False
 
-
 isUnionTypeWithParams : FQName -> MappingContextInfo a -> Bool
 isUnionTypeWithParams name ctx = 
    case Dict.get name ctx of
@@ -100,6 +100,13 @@ isCandidateForDataFrame typeRef ctx=
          isRecordWithSimpleTypes itemTypeName ctx
       _ -> False
 
+isAnonymousRecordWithSimpleTypes : Type.Type () -> MappingContextInfo () -> Bool
+isAnonymousRecordWithSimpleTypes tpe ctx = 
+   case tpe of
+       Type.Record _ fields -> 
+           List.all (\field -> isDataFrameFriendlyType field.tpe ctx) fields
+       _ -> 
+           False
 
 type TypeClassificationState a = 
    TypeClassified (TypeDefinitionClassification a)
@@ -162,13 +169,26 @@ isAliasOfBasicType tpe ctx =
            |> Maybe.withDefault False
       _ -> False
 
+isMaybeOfDataFrameFriendlyType : Type a -> MappingContextInfo a -> Bool
+isMaybeOfDataFrameFriendlyType tpe ctx =
+   case tpe of
+      Type.Reference _ ([["morphir"],["s","d","k"]],[["maybe"]],["maybe"]) [typeArg] ->
+         isDataFrameFriendlyType typeArg ctx
+      _ -> 
+         False
+
+isDataFrameFriendlyType : Type a -> MappingContextInfo a -> Bool
+isDataFrameFriendlyType tpe ctx =
+      isBasicType tpe
+      || (isUnionType tpe ctx)
+      || (isAliasOfBasicType tpe ctx)
+      || (isMaybeOfDataFrameFriendlyType tpe ctx)
+
 classifyActualType : Type a -> MappingContextInfo a -> TypeClassificationState a
 classifyActualType  tpe ctx = 
    case tpe of
        Record _ members ->
-            if List.all (\t -> (isBasicType t.tpe) 
-                               || (isUnionType t.tpe ctx) 
-                               || (isAliasOfBasicType t.tpe ctx)) members then
+            if List.all (\t -> isDataFrameFriendlyType t.tpe ctx) members then
                TypeClassified RecordWithSimpleTypes 
             else 
                TypeWithPendingClassification (Just tpe)
diff --git a/tests/Morphir/Snowpark/MapValueListTests.elm b/tests/Morphir/Snowpark/MapValueListTests.elm
@@ -77,7 +77,7 @@ memberTest =
 memberExpectedTest: Scala.Value
 memberExpectedTest =
     Scala.Apply (Scala.Select (Scala.Variable "v") "in") [ Scala.ArgValue Nothing listExpectedTest ]
-
+  
 mapValueListTest : Test
 mapValueListTest =
     let
@@ -93,7 +93,7 @@ mapValueListTest =
     in
     describe "List functions"
         [
-            assertListTest,
-            assertMemberTest 
+        assertListTest
+        , assertMemberTest
         ]
     
