Scala missing parameter type for expanded function The argument types of an anonymous function must be fully known. (SLS 8.5)

Question

I have the following snippet I need to complete for an assignment. To fulfill the asignment I have to correctly replace the comments /*fulfill ...*/. However I tried my best and I am still getting an

missing parameter type for expanded function The argument types of an anonymous function must be fully known. (SLS 8.5) error.

I found similar questions related to this error. However I could not derive a solution for my paticular problem of those answers.

So the target is to check whether the events fulfill the properties.

I am glad for every hint.

This is the code I need to complete:

import scala.collection.mutable.MutableList

abstract class Event
case class Command(cmdName: String) extends Event
case class Succeed(cmdName: String) extends Event
case class Fail(cmdName: String) extends Event

class Property(val name: String, val func: () => Boolean)

class Monitor[T] {
    val properties = MutableList.empty[Property]

    // (propName: String)(formula: => Boolean) was inserted by me
    def property(propName: String)(formula: => Boolean) /* fulfill declaration here */ {
        properties += new Property(propName, formula _)
    }

    var eventsToBeProcessed = List[T]()

    def check(events: List[T]) {
        for (prop <- properties) {
            eventsToBeProcessed = events

            println(prop.func())                
        }
    }

    def require(func: PartialFunction[T, Boolean]):Boolean = {
        /* Fulfill body */

        // This is what I came up with and what throws the compilation error
        // case event:T => if (func.isDefinedAt(event)) Some(func(event)) else None
        // Edit 1: Now I tried this but it prints that properties evaluate to false
        var result = true
        for (event <- eventsToBeProcessed){
            if (func.isDefinedAt(event)){
                result = result && func(event)
            }
        }
        return  result
    }
}

class EventMonitor extends Monitor[Event] {
    property("The first command should succeed or fail before it is received again") {
        require {
            case Command(c) =>
                require {
                    case Succeed(`c`) => true
                    case Fail(`c`) => true
                    case Command(`c`) => false
                }
        }
    }

    property("The first command should not get two results") {
        require {
            case Succeed(c) =>
                require {
                    case Succeed(`c`) => false
                    case Fail(`c`) => false
                    case Command(`c`) => true
                }
            case Fail(c) =>
                require {
                    case Succeed(`c`) => false
                    case Fail(`c`) => false
                    case Command(`c`) => true
                }
        }
    }

    property("The first command should succeed") {
        /* Add a property definition here which requires that the first command does not fail.
         * It should yield OK with the events listed in the main method.
         */

        // This is what I came up with
        require{
            case Command(c) =>
                require{
                    case Succeed(`c`)=> true
                    case Fail(`c`) => false
                }
        }
    }
}

object Checker {

    def main(args: Array[String]) {
        val events = List(
            Command("take_picture"),
            Command("get_position"),
            Succeed("take_picture"),
            Fail("take_picture")
        )

        val monitor = new EventMonitor
        monitor.check(events)
        // Desired output should be "true false true"
    }
}

`require()` is supposed to return `Boolean` but your code attempts to return `Option[T]` instead. What is being tested (matched against) that _might_ be of type `T`? — jwvh, Nov 26 '18 at 21:10
@jwvh I extended the code: I think the target is to check whether the events fulfill the properties. With the above all properties fail instead of getting the desired output. — HaaLeo, Nov 26 '18 at 22:32
`val func: () => Boolean` means that `func` is a function that takes no input and returns a `Boolean`. How is it supposed to select an output, **true** or **false**, if it takes no input? — jwvh, Nov 27 '18 at 00:37
`formula: => Boolean` means that `formula` is either **true** or **false** but the determination/evaluation is done later ("[call by name](https://stackoverflow.com/a/13337382/4993128)"). I don't think that's what you want. — jwvh, Nov 27 '18 at 00:40

Aleksey Isachenkov · Accepted Answer · 2018-11-27T10:50:09.047

3

You wrote require function that returns T => Option[Boolean] intead of Boolean. You should rewrite it on something like this:

def require(func: PartialFunction[T, Boolean]):Boolean = {
  val left = eventsToBeProcessed.dropWhile(!func.isDefinedAt(_))
  left.headOption.forall(head => {
    eventsToBeProcessed = left.tail
    func(head)
  })
}

edited Nov 27 '18 at 10:50

answered Nov 26 '18 at 21:50

Aleksey Isachenkov

1,230
6
16

Thanks for your answer. Now I understand that the `case` statement was the wrong approach. I extended the code example above. You have an idea how I could get it to return the desired output? – HaaLeo Nov 26 '18 at 22:34
Are you sure that the definition of `require` should look like `def require(func: PartialFunction[T, Boolean]):Boolean`? – Aleksey Isachenkov Nov 26 '18 at 22:59
It seems you need to check there the whole sequence of elements in eventsToBeProcessed at once... – Aleksey Isachenkov Nov 26 '18 at 23:02
Yes the definition of `require` is given. – HaaLeo Nov 26 '18 at 23:03
Have properties definitions been given? – Aleksey Isachenkov Nov 26 '18 at 23:13
`properties` definition has been given but I added the `property` definition – HaaLeo Nov 26 '18 at 23:20
Instead of `eventsToBeProcessed.tail` I had to use `left.tail` so it works properly. For instance it should print "true true true" if the `Fail("take_picture")` event is omitted. However thank you very much for helping out – HaaLeo Nov 27 '18 at 10:19

Scala missing parameter type for expanded function The argument types of an anonymous function must be fully known. (SLS 8.5)

1 Answers1

Linked